Intentos de programacion

viernes, 18 de noviembre de 2011

juego de numeros

Esta aplicación es un juego el cual consiste en acomodar los números del 1 al 15.
les voy a mostrar primero como quedo y después el código para que lo vallan entendiendo sale:

al dar clic a play te aparece la plantilla para iniciar el juego

para mover un numero tienes que dar clic sobre el numero, este se moverá solamente si el cuadro continuo en cualquier dirección esta vació.

aquí tienen el código:

int h;
int cont=0;
int r=0;
int pri1[17];
int fig1[4][4] ;
//arreglo ya definido para checar la posición de las imagenes cuando se gane
int gan[4][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11},{12,13,14,15}};

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
//cargo las imagenes en el arreglo imageObject
ImageObject[0] = new Graphics::TBitmap;
ImageObject[0]->LoadFromFile("l1.bmp");
// ImageObject[0]->Transparent = True;
ImageObject[1] = new Graphics::TBitmap;
ImageObject[1]->LoadFromFile("l2.bmp");
// ImageObject[1]->Transparent = True;
ImageObject[2] = new Graphics::TBitmap;
ImageObject[2]->LoadFromFile("l3.bmp");
// ImageObject[2]->Transparent = True;
ImageObject[3] = new Graphics::TBitmap;
ImageObject[3]->LoadFromFile("l4.bmp");
//ImageObject[3]->Transparent = True;
ImageObject[4] = new Graphics::TBitmap;
ImageObject[4]->LoadFromFile("l5.bmp");
// ImageObject[4]->Transparent = True;
ImageObject[5] = new Graphics::TBitmap;
ImageObject[5]->LoadFromFile("l6.bmp");
//ImageObject[5]->Transparent = True;
ImageObject[6] = new Graphics::TBitmap;
ImageObject[6]->LoadFromFile("7.bmp");
// ImageObject[6]->Transparent = True;
ImageObject[7] = new Graphics::TBitmap;
ImageObject[7]->LoadFromFile("l8.bmp");
//ImageObject[7]->Transparent = True;
ImageObject[8] = new Graphics::TBitmap;
ImageObject[8]->LoadFromFile("l9.bmp");
//ImageObject[8]->Transparent = True;
ImageObject[9] = new Graphics::TBitmap;
ImageObject[9]->LoadFromFile("l10.bmp");
// ImageObject[9]->Transparent = True;
ImageObject[10] = new Graphics::TBitmap;
ImageObject[10]->LoadFromFile("l11.bmp");
// ImageObject[10]->Transparent = True;
ImageObject[11] = new Graphics::TBitmap;
ImageObject[11]->LoadFromFile("l12.bmp");
// ImageObject[11]->Transparent = True;
ImageObject[12] = new Graphics::TBitmap;
ImageObject[12]->LoadFromFile("l13.bmp");
// ImageObject[12]->Transparent = True;
ImageObject[13] = new Graphics::TBitmap;
ImageObject[13]->LoadFromFile("l14.bmp");
// ImageObject[13]->Transparent = True;
ImageObject[14] = new Graphics::TBitmap;
ImageObject[14]->LoadFromFile("l15.bmp");
// ImageObject[14]->Transparent = True;
ImageObject[15] = new Graphics::TBitmap;
ImageObject[15]->LoadFromFile("lv.bmp");
// ImageObject[15]->Transparent = True;

}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{

Form1->InitiateAction();
Form1->PaintBox1->Repaint();
r=0;
cont=0;
//ciclo para obtener los números del 1 al 16 de manera aleatoria para poder saber en que posición se van a
//dibujar las imágenes (números)
int n=0;
for(int i=0;i<=100;i++)
{
int r=0+rand()%16;
for(int j=0;j<=n;j++)
{
if(pri1[j]==r)
{
j=n+1;
n=n-1;
}
if(j==n)
{

pri1[n]=r;

}

}
n++;
if(n==17)
{
break;
}

}
//guarda el numero de la imagen en la matris fig1, este numero es la posicion que tiene la imagen en el arreglo imaenObject
int l=0;
for(int y=0;y<4;y++)
{
for(int j=0;j<4;j++)
{
fig1[j][y]=pri1[l];
l++;
}
}
//matriz que contienen el área donde se dibujaran las imágenes
int x[4]={0,PaintBox1->ClientWidth/4,PaintBox1->ClientWidth/2,(PaintBox1->ClientWidth/4)*3};
int y[4]={0,PaintBox1->ClientHeight/4,PaintBox1->ClientHeight/2,(PaintBox1->ClientHeight/4)*3};
//if(r==1)
// {
Label1->Caption=1;
//array
h=1;
//ciclo para dibujar las imágenes en pantalla
int f=0;
for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++)
{
PaintBox1->Canvas->Draw(x[i],y[j], ImageObject[pri1[f]]);
f++;
}
}

}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseDown(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
PaintBox1->Canvas->Font->Color = clBlue;
PaintBox1->Canvas->Font->Size = 30;
int xl,yl;
int k=0;
//area de dibujo
int x[5]={0,PaintBox1->ClientWidth/4,PaintBox1->ClientWidthClientWidth/4)*3,PaintBox1->ClientWidth};
int y[5]={0,PaintBox1->ClientHeight/4,PaintBox1->ClientHeight/2,(PaintBox1->ClientHeight/4)*3,PaintBox1->ClientHeight};
//checas X,Y que son las coordenados que se obtienen al dar clic sobre la imagen con el área de dibujo
for(int i=0;i<4;i++)
{
if(X>x[i]&&X<x[i+1])
{
xl=i;
}

}
for(int i=0;i<4;i++)
{
if(Y>y[i]&&Y<y[i+1])
{
yl=i;
}

}
Label1->Caption=cont;
if(h==1)
{
//aquí se checa si la imagen sobre la cual se dio clic es continua de la imagen sin numero que es la imagen en posición numero 15, si es así cambia una imagen por otra
k=fig1[yl][xl];
if(fig1[yl+1][xl]==15)//
{
cont++;
// Label1->Caption=cont;
PaintBox1->Canvas->Draw(x[xl],y[yl],ImageObject[15]);
PaintBox1->Canvas->Draw(x[xl],y[yl+1],ImageObject[k]);
fig1[yl][xl]=15;
fig1[yl+1][xl]=k;
}
else
{
if(fig1[yl-1][xl]==15)//||fig1[xl+1][yl]==15||fig1[xl-1][yl]==15)
{
cont++;
// Label1->Caption=cont;
PaintBox1->Canvas->Draw(x[xl],y[yl],ImageObject[15]);
PaintBox1->Canvas->Draw(x[xl],y[yl-1],ImageObject[k]);
fig1[yl][xl]=15;
fig1[yl-1][xl]=k;
}
else
{
if(fig1[yl][xl+1]==15)//||fig1[xl-1][yl]==15)
{
cont++;
// Label1->Caption=cont;
PaintBox1->Canvas->Draw(x[xl],y[yl],ImageObject[15]);
PaintBox1->Canvas->Draw(x[xl+1],y[yl],ImageObject[k]);
fig1[yl][xl]=15;
fig1[yl][xl+1]=k;
}
else
{
if(fig1[yl][xl-1]==15)
{
cont++;

PaintBox1->Canvas->Draw(x[xl],y[yl],ImageObject[15]);
PaintBox1->Canvas->Draw(x[xl-1],y[yl],ImageObject[k]);
fig1[yl][xl]=15;
fig1[yl][xl-1]=k;
}
}
}
}
//fig1[yl][xl]=15;
//método para verificar si ya se gano
if(ganar(h))
{

String text = "Ya ganste";
PaintBox1->Canvas->TextOut(100,310, text);
}
}

}
//---------------------------------------------------------------------------
bool TForm1::ganar(int h)
{
// si la matriz fig que es la que contiene la posición actual de las imágenes es igual a la de gan entonces abras ganado
bool t=true;
if(h==1)
{
for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++)
{
if(fig1[i][j]!= gan[i][j])
{
return t=false;
}
}
}
}
return t=true;
}
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
r++;
Label4->Caption=r;
}

uf al fin gane, créanme no soy buena jugando, y eso que yo lo programe verdad pero bueno.

aquí tienen el código para descargarlo

Fractal Mandelbrot en C#

Anteriormente hice una publicación de el fractal conocido como el fractal de mandelbrot, en una aplicación en c++ builder, en esta aplicación utilizo el mismo algoritmo pero implementado en c#.
aquí les dejo el código de dicha aplicación:

int maxx, maxy, Limite, Pasos, Terminar;
double PasoX, PasoY, PosX, PosY, OrigX, OrigY, DimX, DimY, IterX, IterY, TempX;
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
this.Refresh();
Bitmap bmp = new Bitmap(this.ClientSize.Width, ClientSize.Height);
maxx = this.ClientSize.Width;
maxy = this.ClientSize.Height;
Limite = 100;
OrigX = -2.0;
OrigY = -1.25;
DimX = 0.5;
DimY = 1.25;
PasoX = (DimX - OrigX) / maxx;
PasoY = (DimY - OrigY) / maxy;

for (int i = 0; i < maxx; i++)
for (int j = 0; j < maxy; j++)
{
PosX = OrigX + i * PasoX;
PosY = OrigY + j * PasoY;
IterX = 0.0;
IterY = 0.0;
Terminar = Pasos = 0;
while (Terminar==0)
{
TempX = (IterX * IterX) - (IterY * IterY) + PosX;
IterY = 2 * (IterX * IterY) + PosY;
IterX = TempX;
Pasos++;
double r, s;
r = (double)Math.Abs(IterX) * Math.Abs(IterX);
s =(double) Math.Abs(IterY) * Math.Abs(IterY);
if (Math.Sqrt(r+s) >= 2.0)
Terminar++;
if (Pasos >= Limite) Terminar++;

i=maxx;
j=maxy;
Terminar++;

}
if (Pasos < Limite)
bmp.SetPixel(i, j, Color.Blue);

}
Graphics g = this.CreateGraphics();
g.DrawImage(bmp, 0, 0, bmp.Width, bmp.Height);
}

esta es la ejecución de este código:

aqui puedes descargar la aplicación.

Fractal del Dragon en c#

Recuerdan una publicación anterior donde les presentaba el fractal del dragón usando el algoritmo del dragón el cual esta compuesto por segmentos de lineas que se cruzan siempre en angulo de 90º

este es el código en c#:

int Paso = 4096;
int Signo = -1;
float[] EjeX = new float[4098];
float[] EjeY = new float[4098];
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
timer1.Enabled = true;
}

private void timer1_Tick(object sender, EventArgs e)
{
int i;
Paso = 4096;
Signo = -1;
EjeX[1] = pictureBox1.ClientSize.Width / 4;
EjeX[4097] = 2 * pictureBox1.ClientSize.Height / 4;
EjeY[1] = EjeY[4097] = 2 * pictureBox1.ClientSize.Width / 4;

Random ra = new Random();
Thread.Sleep(1);

for (i = 1; i <= 13; i++)
{

Refresh();

GenerarDragon();//TColor(RGB(random(256), 0, 0)));
Paso /= 2;
Thread.Sleep(1);
//delay(1000);
}

}

public void GenerarDragon()
{
int i, j;
float dx, dy;
float x1,y1,x2,y2,x3,y3;
j = Paso / 2;

Random val = new Random();

Pen pluma = new Pen(Color.FromArgb(val.Next(256), val.Next(256), val.Next(256)));
//clase estatica de c# para dibujar graficos
Graphics g = pictureBox1.CreateGraphics();
for (i = 1; i <= 4096; i += Paso)
{
dx = EjeX[Paso + i] - EjeX[i];
dy = EjeY[Paso + i] - EjeY[i];
Signo *= -1;
EjeX[i + j] = EjeX[i] + (dx + (dy * Signo)) / 2;
EjeY[i + j] = EjeY[i] + (dy - (dx * Signo)) / 2;

x1 = EjeX[i];
y1 = EjeY[i];
x2 = EjeX[i + j];
y2 = EjeY[i + j];
x3 = EjeX[i + Paso];
y3 = EjeY[i + Paso];
g.DrawLine(pluma, x1, y1,x2,y2);
g.DrawLine(pluma, x2, y2,x3,y3);

Thread.Sleep(1);

}
}

private void button2_Click(object sender, EventArgs e)
{
timer1.Enabled = false;
this.Close();
}

este es el resultado de esta

aplicación

para descargar el programa fuente da click aqui

sábado, 15 de octubre de 2011

simular paint

Nuestra aplicación dibuja lineas, círculos y espirales, con ayuda de una clase gráficos que les muestro a continuación.

//---------------------------------------------------------------------------

#pragma hdrstop
#include <math.h>
#include "Graficos1.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)
void Graficos::linea(int x1,int y1,int x2,int y2,TColor color)
{
int dx,dy,steps,k,n,m;
float x_inc,y_inc,x,y;
dx=x2-x1;
dy=y2-y1;
if(abs(dx)>abs(dy))
steps=abs(dx);
else
steps=abs(dy);
x_inc=(float)dx/steps;
y_inc=(float)dy/steps;
x=x1;
y=y1;
n=static_cast<int>(x);
m=static_cast<int>(y);
canvas->Pixels[n][m]=clBlue;
for(k=1;k<steps+1;k++)
{
x=x+x_inc;
y=y+y_inc;
n=static_cast<int>(x);
m=static_cast<int>(y);
canvas->Pixels[n][m]=clBlue;
}

}

//--------------------------------
void Graficos::linea(int x1,int y1,int x2,int y2)
{
int dx,dy,steps,k,n,m;
float x_inc,y_inc,x,y;
dx=x2-x1;
dy=y2-y1;
if(abs(dx)>abs(dy))
steps=abs(dx);
else
steps=abs(dy);
x_inc=(float)dx/steps;
y_inc=(float)dy/steps;
x=x1;
y=y1;
n=static_cast<int>(x);
m=static_cast<int>(y);
canvas->Pixels[n][m]=(TColor)random(255);//clBlue;
for(k=1;k<steps+1;k++)
{
x=x+x_inc;
y=y+y_inc;
n=static_cast<int>(x);
m=static_cast<int>(y);
canvas->Pixels[n][m]=(TColor)random(255);//clBlue;
}

}

void Graficos::circulo_1(int x1,int y1)
{
//int r=Edit3->Text.ToIntDef(50);
int xc=x1;
int yc=y1;
int x,y,r;
r=xc/2;
x=r;
for(int i=0;i<=r;i++)
{
y = yc + sqrt((r*r)-((x-xc)*(x-xc)));
x++;
canvas->Pixels[x][static_cast<int>(y)]=clBlue;
}
x=r;
//xc=100;
//yc=100;
for(int i=0;i<=r;i++)
{
y = yc - sqrt((r*r)-((x-xc)*(x-xc)));
x++;
canvas->Pixels[x][static_cast<int>(y)]=clBlue;
}
x=xc;
//xc=100;
//yc=100;
for(int i=0;i<=r;i++)
{
y = yc + sqrt((r*r)-((x-xc)*(x-xc)));
x++;
canvas->Pixels[x][static_cast<int>(y)]=clBlue;
}
x=xc;
//xc=100;
//yc=100;
for(int i=0;i<=r;i++)
{
y = yc - sqrt((r*r)-((x-xc)*(x-xc)));
x++;
canvas->Pixels[x][static_cast<int>(y)]=clBlue;
}
}

void Graficos::circulo_2(int x1,int y1,int r)
{
float dt,ct,st,x,y,xtemp;
dt=1.0/r;
x=0;
y=r;
ct=cos(dt);
st=sin(dt);
while(x<=y)
{
canvas->Pixels[static_cast<int>(x1+x)][static_cast<int>(y1+y)]=clBlue;
canvas->Pixels[static_cast<int>(x1-x)][static_cast<int>(y1+y)]=clRed;
canvas->Pixels[static_cast<int>(x1+x)][static_cast<int>(y1-y)]=clOlive;
canvas->Pixels[static_cast<int>(x1-x)][static_cast<int>(y1-y)]=clSkyBlue;
xtemp=x;
x=x*ct-y*st;
y=y*ct+xtemp*st;
}
}

void Graficos::circulo_3(int x1,int y1,int r)
{
float pi=M_PI*2.0;
float dth,ct,st,x,y,xtemp;
if(r!=0)
{
dth=pi/(16*r);
ct=cos(dth);
st=sin(dth);
x=0;
y=r;
for(int i=0;i<=(16*r);i++)
{
xtemp=x;
x=x*ct+y*st;
y=y*ct-xtemp*st;
canvas->Pixels[static_cast<int>(x1+x)][static_cast<int>(y1+y)]=clSkyBlue;
Sleep(30);
}
}
}

void Graficos::circulo_4(int x1,int y1,int r)
{
int x,y;
for(int grados=0;grados<360;grados++)
{
x=x1+r*cos(grados/180.0+M_PI);
y=y1+r*sin(grados/180.0+M_PI);
canvas->Pixels[x][y]=clBlue;
Sleep(10);
}
for(int grados=0;grados<360;grados++)
{
x=x1+r*cos(grados/90.0+M_PI);
y=y1+r*sin(grados/90.0+M_PI);
canvas->Pixels[x][y]=clBlue;
Sleep(10);
}
for(int grados=0;grados<360;grados++)
{
x=x1+r*cos(grados/M_PI);
y=y1+r*sin(grados/M_PI);
canvas->Pixels[x][y]=clBlue;
Sleep(10);
}
}

recibimos las coordenadas de el área donde quiere el usuario dibujar y con un botton hacemos el llamado al método de la clase gráficos.

los espirales los hacemos dibujando lineas del método linea como sigue:

int xc=Form1->PaintBox1->ClientWidth/2, yc=Form1->PaintBox1->ClientHeight/2,radio=5;

double pi=M_PI*2.0;

int count=0;

double dth,cth,sth,x,y,x_temp,xt,yt;

dth=pi/(16*radio);

cth=cos(dth);

sth=sin(dth);

x=0.0;

y=radio;

xt=xc+x;

yt=yc+y;

{

x_temp=x;

x=x*cth-y*sth;

y=y*cth+x_temp*sth;

if(x>0)

x +=0.5;

else

x-=0.5;

if(y>0)

y+=0.5;

else

y-=0.5;

//Form1->PaintBox1->Canvas->Pixels[floor(xt+0.5)][floor(yt+0.5)]=clRed;

/*x1=floor(xt+0.5);

y1=floor(yt+0.5);

x2=floor(xc+0.5);

y2=floor(yc+0.5);

g->linea(x1,y1,x2,y2);*/

xt=xc+x;

yt=yc+y;

count++;

Sleep(5);

}

while(count<=350);

Así quedo nuestra aplicación.

dibujando linea:

dibujando el circulo dado el centro de este

dibujando circulo con coordenadas del centro y radio

dibujando el circulo poco a poco:

dibujando el circulo calculando los ángulos:

dibujando espiral:

espiral 1:

espiral 2:

Agregando efectos a espiral:

Aquí puedes descargar

Fractal de ecena

esta aplicación es un paisaje en movimiento, dibujo un sol y dos lineas que simulan la playa y el relieve, aplico color para simular el paisaje.
este es el código del fractal

#define MAXLEVEL 6
#define MAXSIZE 1000
#define WATER 1
#define SUN 2
#define SKY 3
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
int x1;
double frctl[MAXSIZE];
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void TForm1::fractal(int y1,int y2,int maxlevel,double h,double scale)
{
int first, last;
double ratio,std;

first=0;
last=(int)pow(2.0,(double)maxlevel);
frctl[first]=y1;
frctl[last]=y2;
ratio=1.0/pow(2.0,h);
std=scale*ratio;
subdivide(first,last,std,ratio);
}
void TForm1::subdivide(int p1,int p2,double std,double ratio)
{
int midpnt;
double stdmid;
midpnt = (p1 + p2) / 2;
if(midpnt != p1 && midpnt != p2)
{
frctl[midpnt] = (frctl[p1] + frctl[p2]) / 2 + (double)((random(16)-8)) /8.0*std;
stdmid = std * ratio;
subdivide(p1,midpnt,stdmid,ratio);
subdivide(midpnt,p2,stdmid,ratio);
}
}
void TForm1::draw_fractal()
{
int i,x,xinc,l;

l=(int)pow(2.0,(double)MAXLEVEL);
xinc = cw / l * 3 / 2;
Form1->PaintBox1->Canvas->MoveTo(.5,100);
for(i=0,x=0;i<l;i++,x+=xinc)
Form1->PaintBox1->Canvas->LineTo(x,(int)frctl[i]);

}
void __fastcall TForm1::FormCreate(TObject *Sender)
{
cw=Form1->PaintBox1->ClientWidth;
ch=Form1->PaintBox1->ClientHeight;
x1=50;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
x1++;
randomize();

Form1->PaintBox1->Canvas->Brush->Color=clOlive;
Form1->PaintBox1->Canvas->Rectangle(0,0,cw,ch);
Form1->PaintBox1->Canvas->Brush->Color=clBlue;//Color del cielo
Form1->PaintBox1->Canvas->Pen->Color=clMaroon;//contorno de la montaña
fractal(100,100,MAXLEVEL,.75,50.0);
draw_fractal();

Form1->PaintBox1->Canvas->FloodFill(1,2,clMaroon,fsBorder); //fsSurface ó fsBorder
Form1->PaintBox1->Canvas->Pen->Color=clGreen;

fractal(170,170,MAXLEVEL,0.9,30.0);
draw_fractal(); // (TColor)WATER,fsSurface
Form1->PaintBox1->Canvas->Brush->Color=clSkyBlue;
Form1->PaintBox1->Canvas->FloodFill(1,ch-2,clGreen,fsBorder);

Form1->PaintBox1->Canvas->Brush->Color=clYellow;//relleno del sol

Form1->PaintBox1->Canvas->Ellipse(5+x1,5,40+x1,40);
Form1->PaintBox1->Canvas->FloodFill(cw-100 ,10,(TColor)SUN,fsSurface);

}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Timer1->Enabled=true;
}
//------------------------

Este es el resultado:

aquí puedes descargar

Fractal del Dragon

En esta aplicación dibujamos el fractal del dragón la cual es una imagen compuesta por lineas del mismo tamaño.
Este es el método que genera al dragón:

void TForm1::GenerarDragon(TColor color)
{
int i, j,dx,dy;
j=Paso/2;
//setcolor(color);
Canvas->Pen->Color=color;
for(i=1;i<=4096;i+=Paso)
{
dx=EjeX[Paso+i]-EjeX[i];
dy=EjeY[Paso+i]-EjeY[i];
Signo*=-1;
EjeX[i+j]=EjeX[i]+(dx+(dy*Signo))/2;
EjeY[i+j]=EjeY[i]+(dy-(dx*Signo))/2;

Canvas->MoveTo(EjeX[i],EjeY[i]);
Canvas->LineTo(EjeX[i+j],EjeY[i+j]);
Canvas->MoveTo(EjeX[i+j],EjeY[i+j]);
Canvas-> LineTo(EjeX[i+Paso],EjeY[i+Paso]);

Sleep(1);

}
}

Este es el resultado;

Aqui puedes descargar

fractal Mandelbrot

En esta aplicacion dibujamos el gractal de Mandelbrot en c++ builder.
este es el codigo para dibujarlo:

this->Repaint();
maxx=this->ClientWidth;
maxy=this->ClientHeight;
Limite=100;
OrigX=-2.0;
OrigY=-1.25;
DimX=0.5;
DimY=1.25;
PasoX=(DimX-OrigX)/maxx;
PasoY=(DimY-OrigY)/maxy;

for(int i=0;i<=maxx;i++)
for(int j=0;j<=maxy;j++)
{
PosX=OrigX+i*PasoX;
PosY=OrigY+j*PasoY;
IterX=0.0;
IterY=0.0;
Terminar=Pasos=0;
while(!Terminar)
{
TempX=(IterX*IterX)-(IterY*IterY)+PosX;
IterY=2*(IterX*IterY)+PosY;
IterX=TempX;
Pasos++;

if(hypot(fabs(IterX),fabs(IterY))>=2.0)
Terminar++;
if(Pasos>=Limite)Terminar++;

}
if(Pasos<Limite)
this->Canvas->Pixels[i][j]=clBlue;
}

y este es el resultado:

aquí puedes descargarlo