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
 |
| Sequencia de introdução do game |
 |
| Game rodando em debug no Lázarus |
 |
| Inimigos, pontuação e colisões! |
 |
| Modelo do controle usado para os testes |
 |
| Você não precisa ver toda a escada, simplesmente dê o primeiro passo! |
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.