Este jogo foi originalmente escrito em Delphi 7 no final de 2003 como um exercício de aprendizado da linguagem Object Pascal e da programação de jogos do Windows.
Ele abriu e foi compilado perfeitamente 21 anos depois, no Delphi 12. Cara, isso é simplesmente incrível!!! 😮
Essa é a cara dele rodando no Windows 11!
Espero que apreciem.
Repositório: https://github.com/fabianosalles/yams
Página de relase: https://github.com/fabianosalles/yams/releases
TDataset, run a sql query, call the open method and bingo! We have a copy of the records (and a multitude of metadata) in memory, ready to be manipulated.procedure Foo;
var
qry: TSqlQuery;
begin
qry := TSqlQuery.Create;
try
qry.CommandText := 'select some fields from some table';
qry.Open;
while not qry.Eof do
begin
{ some proccessing oncurrent row }
qry.Next;
end;
finally
qry.Close;
FreeAndNil(qry);
end;
end;
procedure Foo;
var
qry: TSqlQuery;
begin
qry := TSqlQuery.Create;
try
qry.CommandText := 'select some fields from some table';
qry.Open;
while not qry.Eof do
begin
//processa o registro atual..
//e avança para o próximo
qry.Next;
end;
finally
qry.Close;
FreeAndNil(qry);
end;
end;
 |
| Saída gerada pelo conversor |
 |
| Saída da 2ª animação em modo texto. Bem mais interessante. |
 |
| Saída da 1ª animação em modo texto. Bem vindo à Matrix! :) |
Consoles gerenciam inputs e outpus (I/O) para aplicações em modo caractere (aplicações que não providenciam sua própria interface gráfica).
No artigo anterior, criamos uma animação procedural, onde com um algoritmo simples, um padrão de cores foi gerado. Neste artigo vamos criar um efeito sobre uma imagem já existente utilizando um conceito simples de transparência.
A opacidade é uma propriedade óptica da matéria. Um material é considerado opaco quando não permite a passagem da luz em quantidades apreciáveis. Geralmente, diz-se que um material é opaco quando bloqueia a passagem da luz visível. (http://pt.wikipedia.org/wiki/Opacidade)
Para nossos estudos, vamos definir opacidade como sendo o nível de transparência de uma imagem cujo valor será representado por um byte, o que nos dá uma faixa de 256 valores possíveis (0..255) onde 0 define uma imagem completamente transparente e 255 uma imagem completamente opaca.TSprite = class(TBitmap) private fOpacity: byte; procedure SetOpacity(const Value: byte); published property Opacity: byte read FOpacity write SetOpacity; end;
procedure TForm1.FormCreate(Sender: TObject);
begin
ReportMemoryLeaksOnShutdown := True;
ClientWidth := 800;
ClientHeight := 600;
fOffScreen := TBitmap.Create;
fOffScreen.PixelFormat := pf24bit;
fOffScreen.Width := ClientWidth;
fOffScreen.Height := ClientHeight;
fOffScreen.Canvas.Font.Color := clGray;
fOffScreen.Canvas.Font.Size := 9;
sprite := TSprite.Create;
sprite.LoadFromFile('img01.bmp');
sprite.Opacity := MAXBYTE div 2;
Application.OnIdle := OnIdle;
end;
50% de opacidade sobre um background preto (note que já configuramos opacidade como MAXBYTE div 2).procedure TForm1.DrawToBuffer; var Canvas : TCanvas; Blendf : TBlendFunction; begin Canvas := fOffScreen.Canvas; Canvas.Brush.Color := clBlack; Canvas.FillRect(fOffScreen.Canvas.ClipRect); Blendf.BlendOp := AC_SRC_OVER; Blendf.BlendFlags := 0; Blendf.SourceConstantAlpha := sprite.Opacity; Blendf.AlphaFormat := AC_SRC_OVER; end;
BlendOp representa a opração de mesclagem a executar. Como queremos copiar nosso sprite “por cima” da imagem de fundo, setamos BlendOP com a constante AC_SRC_OVER.BlendFlags deve ser sempre zero.SourceConstantAlpha define um valor de transparência a ser aplicado na imagem de origem. Aqui, simplesmente passamos o valor da opacidade de nosso sprite.AlphaFormat deve ser AC_SRC_OVER para que o Windows não tente buscar informações de transparência nos pixels da imagem de origem, aplicando em vez disto, o valor de SourceConstantAlpha.TBlendFunction configurado, podemos desenhar o sprite semi-transparente. Complemente o método DrawToBuffer conforme a listagem abaixo e execute o programa para ver o resultado.procedure TForm1.DrawToBuffer;
var
Canvas : TCanvas;
Blendf : TBlendFunction;
begin
Canvas := fOffScreen.Canvas;
Canvas.Brush.Color := clBlack;
Canvas.FillRect(fOffScreen.Canvas.ClipRect);
Blendf.BlendOp := AC_SRC_OVER;
Blendf.BlendFlags := 0;
Blendf.SourceConstantAlpha := sprite.Opacity;
Blendf.AlphaFormat := AC_SRC_OVER;
Windows.AlphaBlend(
Canvas.Handle, {manipulador da imagem de destino}
fOffScreen.Width - sprite.Width, {coordenada X}
0, {coordenada Y}
sprite.Width, {largura da área de desenho}
sprite.Height, {altura da área de desenho}
sprite.Canvas.Handle, {manipulador da imagem de origem}
0, {coordenada X}
0, {coordenada Y}
sprite.Width, {largura da imagem de origem}
sprite.Height, {altura da imagem de origem}
Blendf {parâmetros de executação(TBlendFunction)}
);
Canvas.TextOut(10, 10, Format('Opacidade : %d', [sprite.Opacity]));
end;
Se tudo estiver certo, você vai ver uma imagem no canto esquerdo da tela de seu programa. A imagem parece muito escura porque metade a luminosidade foi misturada com o fundo negro. Altere o valor de opacidade do sprite para chegar a resultados diferentes.Opacity ao longo do tempo. Vejamos como ficará o método UpdateAnimation.procedure TForm1.UpdateAnimation;
begin
if OpIncreasing then
sprite.Opacity := sprite.Opacity + 1
else
sprite.Opacity := sprite.Opacity - 1;
case sprite.Opacity of
0 : OpIncreasing := true;
255 : OpIncreasing := false;
end;
end;
No artigo anterior, configuramos um formulário padrão da VCL para que pudéssemos exibir animações em sua superfície. Criamos também uma bola, que podíamos manipular pelas setas do teclado e fazê-la se mover pela tela. Nesta parte, vamos falar um pouco de teoria e criar nossa primeira animação procedural.
O sistema ocular humano é limitado quanto ao espectro visível de luz e quanto à velocidade de interpretação das imagens. O cérebro, porém, é muito bom no trabalho de contornar estas limitações e nos fazer enxergar imagens corretas, nítidas e sem quebras. Mas este trabalho de interpretação está sujeito a falhas e são essas falhas de interpretação que causam as famosas ilusões de ótica. A animação por computador é um tipo de ilusão projetada para causar ao o observador a impressão de movimento.TBitmap, oferece um excelente meio de manipular essas imagens, e o método BitBlit da API do Windows, nos fornece um modo rápido de copiar imagens para o frame buffer.IDrawable e fazer com que nosso objeto TBackground a implemente.IDrawable = interface
['{3E41F055-58F6-4990-9C94-AA29FD4D7CF4}']
function GetVisible: boolean;
function GetRect : TRect;
procedure SetVisible(const Value: boolean);
procedure Draw(Canvas:TCanvas);
property Rect: TRect read GetRect;
property Visible: boolean read GetVisible write SetVisible;
end;
A interface é bem intuitiva e dispensa maiores explicações. Ela irá definir o “contrato” para todos os objetos renderizáveis no nosso programa. Agora segue nova definição de TBackground adaptado para implementar IDrawable.TBackgroung = class(TInterfacedObject, IDrawable)
private
fStep: byte;
fSize: uCommon.TSize;
fVisible: boolean;
function GetVisible: boolean;
function GetRect : TRect;
procedure SetVisible(const Value: boolean);
public
constructor Create(pWidth: integer=640; pHeight:integer=480);
destructor Free;
published
{IDrawable}
property Rect: TRect read GetRect;
property Visible: boolean read GetVisible write SetVisible;
{TBackgroung}
property Size : uCommon.TSize read fSize;
property Step : byte read fStep write fStep;
end;
Além das propriedades e métodos da interface, criamos duas outras, Size e Step, que irão nos auxiliar no controle da renderização e no controle da animação. Vamos criar uma série de quadros vermelhos que irão mudar de cor de acordo com o valor da propriedade Step. Para isto, vamos implementar o método Draw.procedure TBackgroung.Draw(Canvas: TCanvas);
const
SquareW = 40; {largura de cada bloco}
SquareH = 40; {altura de cada bloco}
SquaresC = 640 div SquareW + 1; {colunas}
SquaresR = 480 div SquareH + 1; {linhas}
var
col, row, i : integer;
r : TRect;
begin
if fVisible then begin
for col:=0 to SquaresC-1 do
for row :=0 to SquaresR-1 do begin
r.Left := Col * SquareW;
r.Top := Row * SquareH;
r.Right := r.Left + SquareW;
r.Bottom := r.Top + SquareH;
Canvas.Brush.Color := col * row + Step;
Canvas.FillRect(r);
end;
end;
end;
SquareW (a largura de cada quadrado) e SquareH (altura de cada quadrado), atribuir a cada um destas “células” uma cor diferente, que calculamos com base na linha, na coluna e no valor da propriedade Step para finalmente, desenharmos uma a uma as “células” no Canvas.Step após cada renderização. Faremos isto no nosso loop principal através do método UpdateAnimation.procedure TForm1.OnIdle(Sender: TObject; var Done: Boolean); begin ProcessInput; UpdateAnimation; DrawToBuffer; Blit; Done := False; end;
procedure TForm1.UpdateAnimation; begin BackGnd.Step := BackGnd.Step + 1; end;Pronto! Nosso background animado está concluído. Execute o código para ver o padrão vermelho mudando de tom e experimente brincar com as constantes do método Draw para chegar a outros resultados. Observe que a classe
TBall também foi alterada para implementar a interface IDrawable e que uma outra interface (IMoveable) foi criada para definir os objetos capazes de se mover pela tela.No post anterior, fizemos uma introdução ao conceito de “Double buffer” e realizamos o tratamento da mensagem WM_ERASEBKGND para ajudar a otimizar um formulário VCL com o intuito de exibir animações de qualidade nele. Neste post, iremos finalizar estas otimizações.
O objeto Application está presente em todos os programas GUI do Delphi e é utilizado para simplificar a interação com a API do Windows. De fato, o objeto Application encapsula todas as chamadas à API necessárias para inicializar, registrar e manipular janelas, além de publicar alguns eventos globais.TApplication.OnIdle é um desses eventos. Ele é disparado sempre que o programa fica ocioso, ou seja, sempre que não houver mais nenhuma instrução a ser executada, o evento OnIdle será chamado. Isso o torna especialmente útil quando queremos realizar uma tarefa em segundo plano sem utilizar threads, ou quando queremos que uma determinada função seja executada repetidamente sem afetar o desempenho do programa.OnIdle.procedure OnIdle(Sender: TObject; var Done: Boolean); begin Done := false; end;
Application.OnIdle para que, dessa forma, possamos associar nosso método ao evento.OnCreate do formulário e estaremos prontos para realizar nosso processamento neste evento.procedure TfrmCGScreen.FormCreate(Sender: TObject); begin Application.OnIdle := OnIdle; end;
OnIdle para nosso loop principal.1. INICIO 2. ENQUANTO(ESTADO <> SAIR) 2.1. PROCESSA OS COMANDOS DO USUÁRIO; 2.2. ATUALIZA DO ESTADO DA ANIMAÇÃO; 2.3. DESENHA A CENA NO BUFFER; 2.4. EXIBE A CENA NO MONITOR; 3. FIM;
Ctl + Shit + C para que o Delphi crie a implementação de todos:
procedure ProcessInput; {passo 2.1}
procedure UpdateAnimation; {passo 2.2}
procedure DrawToBuffer; {2.3}
procedure Blit; {2.4}
OnIdle para que a estrutura do nosso algoritmo fique completa.procedure TForm1.OnIdle(Sender: TObject; var Done: Boolean); begin ProcessInput; UpdateAnimation; DrawToBuffer; Blit; end;
TBall (adicione o arquivo uBall.pas ao seu projeto) no centro da tela. Declare uma variável pública chamada Ball e modifique o evento OnCreate do formulário para:procedure TForm1.FormCreate(Sender: TObject);
begin
ReportMemoryLeaksOnShutdown := True;
{teremos uma tela de 800 x 600 pixels}
ClientWidth := 800;
ClientHeight := 600;
{Criamos nosso bitmap de buffer}
fOffScreen := TBitmap.Create;
{iremos trabalhar com cores de 24bit}
fOffScreen.PixelFormat := pf24bit;
{configura as dimensões do buffer de acordo com as dimensões do formulário}
fOffScreen.Width := ClientWidth;
fOffScreen.Height := ClientHeight;
Ball := TBall.Create;
Ball.Position:= Point(ClientWidth div 2, ClientHeight div 2);
Ball.Color := clWhite;
Ball.Diameter := 30;
Application.OnIdle := OnIdle;
end;
DrawToBuffer e Blit:procedure TForm1.DrawToBuffer;
var
Canvas : TCanvas;
begin
Canvas := fOffScreen.Canvas;
{Primeiro, limpamos o buffer com um fundo preto...}
Canvas.Brush.Color := clBlack;
{Agora desenhamos a bola}
Canvas.FillRect(fOffScreen.Canvas.ClipRect);
Ball.Draw(Canvas);
end;
procedure TForm1.Blit;
begin
BitBlt(Canvas.Handle, 0, 0, ClientWidth, ClientHeight,
fOffScreen.Canvas.Handle, 0, 0, SRCCOPY);
end;
ProccessInput usando a função GetKeyState como na listagem abaixo. Note que os botões + e - irão manipular a velocidade em que a bola se movimenta.procedure TForm1.ProcessInput;
begin
if GetKeyState(VK_UP) then
Ball.Move(0,-1);
if GetKeyState(VK_DOWN) then
Ball.Move(0, 1);
if GetKeyState(VK_LEFT) then
Ball.Move(-1, 0);
if GetKeyState(VK_RIGHT) then
Ball.Move(1, 0);
if GetKeyState(VK_SUBTRACT) then
Ball.Speed := Ball.Speed - 0.1;
if GetKeyState(VK_ADD) then
Ball.Speed := Ball.Speed + 0.1;
end;
TBall é responsável por este tratamento.TBall para trabalhar com sprites animados.
O Delphi facilita muito a construção de interfaces gráficas. Arrastando componentes da barra de ferramentas e alterando suas propriedades pelo “object inspector”, é muito fácil construir uma interface consistente para a maioria das aplicações.TCanvas representa uma superfície de desenho que pode ser entendida e tratada como um array de pixels ou um buffer de pixels. O Windows mapeia este buffer para a memória de vídeo e então a placa de vídeo trata de interpretar esta informação e convertê-la em uma imagem visível no monitor.TCanvas de um objeto visível, o desenho será imediatamente atualizado na tela. Até aí, tudo bem. Desde que sejam desenhados um ou dois objetos por vez, tudo irá ser atualizado rápido o suficiente para que a transição não seja facilmente percebida.TTimer num form, configure a propriedade interval para 20, carregue uma imagem qualquer num TImage e ponha o seguinte código no evento OnTimer:procedure TForm1.Timer1Timer(Sender: TObject);
begin
Canvas.Brush.Color := clWhite;
Canvas.FillRect(Canvas.ClipRect);
Canvas.Draw(X, Y, Image1.Picture.Graphic);
Inc(X);
Inc(Y);
if X >= ClientWidth - Image1.Width then
X := 0;
if Y >= ClientHeight - Image1.Height then
Y := 0;
end;
TCanvas visível, a operação demora mais porque, além do tempo gasto com o desenho em si, o programa tem que esperar a memória de vídeo ser atualizada para que o as mudanças apareçam na tela e o programa possa seguir. Quando desenhamos na memória (num TCanvas não visível) este atraso não existe, logo, a operação é concluída muito mais rápido. Além disso, quando vamos exibir a imagem na tela, ela já está pronta e somente uma operação de desenho será realizada nesta “área lenta”, o que contribui para que a animação tenha uma aparência mais agradável.TBitmap para ser o nosso “back buffer” e trate a inicialização e destruição deste objeto:private
{ Private declarations }
fOffScreen: TBitmap;
(...)
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
FreeAndNil(fOffScreen);
end;
(...)
procedure TForm1.FormCreate(Sender: TObject);
begin
X := 0;
Y := 0;
fOffScreen := TBitmap.Create;
fOffScreen.PixelFormat := pf24bit;
fOffScreen.Width := ClientWidth;
fOffScreen.Height := ClientHeight;
end;
procedure TForm1.Timer1Timer(Sender: TObject);
begin
fOffScreen.Canvas.Brush.Color := clWhite;
fOffScreen.Canvas.FillRect(fOffScreen.Canvas.ClipRect);
fOffScreen.Canvas.Draw(X, Y, Image1.Picture.Graphic);
BitBlt(Canvas.Handle, 0, 0,
ClientWidth,
ClientHeight,
fOffScreen.Canvas.Handle,
0, 0, SRCCOPY);
Inc(X);
Inc(Y);
if X >= ClientWidth - Image1.Width then
X := 0;
if Y >= ClientHeight - Image1.Height then
Y := 0;
end;
WM_ERASEBKGND que o Windows envia ao programa quando ele acha que alguma área da janela deve ser atualizada.procedure WMEraseBg(var Msg: TWMEraseBkgnd); message WM_ERASEBKGND;
MSG para 0:procedure TfrmCGScreen.WMEraseBg(var Msg: TWMEraseBkgnd); begin Msg.Result := 0; end;
TTimer por funções mais precisas como QueryPerformaceCounter e utilizar o evento OnIdle do TApplication para realizar os desenhos da animação.File > New > Other, escolha o formulário adicionado anteriormente, marque a opção “inherit” e sobrescreva o método DrawScene para criar suas animações.
Segundo a dinâmica das partículas, um sistema de partículas é o conjunto de leis físicas que regem um conjunto de n partículas partindo de um centro de massa ou emissor. Muitos fenômenos podem ser modelados como sistemas de partículas. A chuva (cada gota é uma partícula e o emissor é o conjunto de nuvens de onde as gotas vêm), a neve (cada floco uma partícula e o emissor, o ponto de condensação/cristalização do vapor de água) o fogo (cada chama é uma partícula e o emissor é o material sendo queimado), todos estes podem ser descritos como tal.