Hoje venho dar algumas dicas de como conseguir um trabalho com programação de jogos.
Vejo muita gente discutindo assuntos do tipo que linguagem utilizar, que biblioteca usar e por aí vai. Claro isto é importante mas não é o fim. Ponha-se no lugar do entrevistador: se você fosse contratar alguém para trabalhar fazendo um jogo como você iria medir as habilidades desta pessoa para saber se ela realmente sabe o que diz? Simples: PORTFOLIO.
O portfolio
O seu portfolio não precisa mostrar projetos excessivamente grandes (esqueça aquela sua idéia brilhante de MMORPG) mas sim mostrar sua habilidade para fazer um jogo completo, funcional e polido.
Não importa se será o milésimo clone de um pong, breakout, pacman, mario, não importa se você está usando javascript, c++, c#, programação orientada a objetos (desejável), linux, windows, mac, etc etc. O que importa é você ter o projeto pronto e disponível (facilmente acessível e testável, seja através de um executável, uma página especial com vídeos, etc). Você não precisa nem se preocupar se a estrutura do seu código estará perfeita ou não (embora seja recomendável dar uma atenção nesta parte). O simples fato de mostrar o jogo pronto é um atestado de que você entende os conceitos.
Hoje em dia você tem tudo disponível: com uma boa conexão de internet você pode pegar diversos tutoriais, recursos, artigos, livros, técnicas, tirar dúvidas em chats, todos os recursos necessários para aprender (todos os jogos “clássicos” possuem exemplos prontos para download de código fonte em diversas linguagens, é só dar uma pesquisada na internet).
O mais importante mesmo é ter disciplina, objetivo, foco e fazer cada pequeno passo para chegar no seu objetivo (tá parecendo até blog de autoajuda).
Faça o que eu digo, não faça o que eu faço…
O leitor pode estar pensando: tá tudo bem, dica interessante mas você trabalha na indústria?
Bom, agora posso dizer que sim….
Recentemente consegui uma vaga como programador em uma empresa chamada MyPlay Mobile para desenvolver jogos para iPhone. É uma empresa pequena em início de carreira mas temos grandes planos (como qualquer empresa) e know-how para fazer o barco andar. No meu caso o que realmente ajudou foi o blog que serviu como um “atestado de conhecimento”.
Até a próxima.
PS: se você trabalha na indústria e quer compartilhar a sua história conosco fique à vontade para comentar.
abril 6th, 2009
Olá pessoal.
Continuando a série sobre o game loop, este artigo irá demonstrar uma versão “revisada” sobre os outros dois anteriores.
Basicamente revisei o código, e expliquei melhor algumas coisas. Também simplifiquei e melhorei um pouco o estilo.
No geral gameloops se resumem em um conceito: controle de tempo. O gameloop exibido abaixo é uma versão bem simples, mas podemos fazer uma versão bem mais complicada onde temos um timer diferente para a lógica e outro para a renderização, podemos calcular quanto tempo cada frame deve levar e deixar o frame apenas ser exibido se ainda houver tempo (descartando quando não der).
Tem também uma técnica para fazer gameloops que não depende da limitação por frames e sim de quanto tempo resta baseado em cálculos por “delta”, ou “tempo decorrido por frame”.
Para aprender bem isso, recomendo um estudo aprofundado das funções de timer do allegro.
Abaixo segue o código revisado:
/*
======================================
Exemplo da implementacao de um Game Loop em Allegro
com algumas explicacoes
por Vitor Almeida da Silva
03/2009
======================================
*/
// inclui o header da biblioteca Allegro
#include <allegro.h>
/*
====================
variaveis globais
====================
*/
bool fimJogo = false; // flag que indica se o jogo deve ou nao continuar
volatile int ticks = 0; // esta variavel ira ser um contador de ticks do clock principal
// do jogo
// cada tick a mais significa que um ciclo de logica do jogo
// foi processado
// esta variavel eh incrementada a cada tick de logica do jogo
// dimensoes do video
int videoLargura = 640; // quantidade de pixels de largura do video
int videoAltura = 480; // quantidade de pixels de altura do video
int videoProfundidade = 32; // quantidade de bits de profundidade (numero de bits que cada pixel tera)
BITMAP *buffer; // bitmap que ira guardar tudo o que desenharmos (para depois ser "jogado" na tela")
// este bitmap eh de suma importancia pois cada funcao de desenho
// que desenha em um bitmap provavelmente devera ser apontada
// para este bitmap
const int FPS_DESEJADO = 60; // quantidade de frames que queremos idealmente que sejam calculados e exibidos em um segundo
volatile int totalFps = 0; // contador que guarda o total de frames por segundo (calculado apenas uma vez a cada segundo)
volatile int frames = 0; // contador utilizado para calcular a quantidade de frames por segundo (incrementado a cada tick do clock)
/*
====================
prototipos das funcoes
====================
*/
void inicializa();
void finaliza();
void atualizaTicker();
void contaSegundos();
/*
=======
main
Funcao principal
Aqui temos o ponto de entrada da aplicacao onde o Game Loop sera executado
=======
*/
int main(int argc, char *argv[]) {
// realiza todas as inicializacoes necessarias
inicializa(); // a partir deste ponto temos a aplicacao pronta para iniciar o game loop
// inicio do game loop
// neste caso o game loop continua executando enquanto nao pressionarmos
// a tecla esc, mas voce pode verificar por uma outra variavel ou condicao
while (!fimJogo) { // inicio do processamento da logica do jogo
while (ticks > 0) { // aqui iniciamos o processamento da logica do jogo
// neste ponto, voce devera inserir o codigo responsavel
// processamento da logica do seu jogo, isto inclui: deteccao de colisao
// inteligencia artificial, calculos diversos, etc
// aqui esta o segredo:
// a variavel abaixo "ticks" eh decrementada, mas lembre-se que ela
// tambem eh incrementada pela funcao de timer, entao qual eh a logica?
// Lembre-se que o timer do ticks eh executado em um intervalo fixo
// entao o decremento tambem devera ocorrer pelo menos N vezes (ver variavel FPS_DESEJADO), isto garante
// que a logica do jogo sera executada pelo menos N vezes
if (key[KEY_ESC]) fimJogo = true; // se pressionou a tecla esc entao finaliza o jogo
ticks--; // decrementa o contador de ticks
// apos a saida concluida, incrementamos o contador de frames, pois
// temos mais um frame executado
frames++;
}
// fim do processamento da logica do jogo
// quando chegarmos ateh aqui significa que a variavel ticks esta com valor
// zerado, entao ja executamos toda a logica do jogo, agora eh hora
// de exibir o resultado na tela
// para exibir o resultado na tela, toda a saida deve ser desenhada
// no bitmap buffer declarado anteriormente
// limpa o buffer com a cor preta
clear_to_color(buffer, makecol(0, 0, 0));
// exibe um contador de frames por segundo
// descomente se quiser exibir o contador
// textprintf(buffer, font, 0, 0, -1, " FPS: %i " , totalFps);
// copia todo o conteudo desenhado no buffer para a tela (exibindo assim o resultado do processamento)
blit(buffer, screen, 0, 0, 0, 0, videoLargura, videoAltura);
rest(1); // evita que a aplicacao monopolize o processador
}
// executa todas as finalizacoes necessarias
finaliza();
return 0; // retorna um codigo de OK para o sistema operacional
}END_OF_MAIN();
/*
=======
inicializa
Realiza qualquer procedimento necessario para iniciar o jogo
Isto inclui iniciar a janela e deixa-la preparada para ser desenhada, iniciar
o estado do jogo, posicoes iniciais, nivel inicial e tudo o que for necessario
=======
*/
void inicializa() {
int res;
allegro_init();
set_color_depth(videoProfundidade);
res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, videoLargura, videoAltura, 0, 0);
if (res != 0) {
allegro_message(allegro_error);
exit(-1);
}
install_timer();
install_keyboard();
install_mouse();
// aqui inicializamos o nosso timer de ticks
// trancando o espaco de memoria da variavel ticks e da funcao timer
// assim elas nao sofrem alteracoes externas
// note que a funcao ticker sera chamada FPS_DESEJADO vezes por segundo, isto eh,
// a logica do nosso jogo sera executada FPS_DESEJADO vezes em um segundo
LOCK_VARIABLE(ticks);
LOCK_FUNCTION(atualizaTicker);
install_int_ex(atualizaTicker, BPS_TO_TIMER(FPS_DESEJADO));
// aqui ocorre o mesmo processo para o timer dos segundos
// note que o timer sera chamado apenas uma vez por segundo
LOCK_FUNCTION(contaSegundos);
install_int_ex(contaSegundos, BPS_TO_TIMER(1));
// cria um bitmap com uma dimensao grande o suficiente para caber na tela
buffer = create_bitmap(videoLargura, videoAltura);
set_window_title("VSoftGames - Teste do Game Loop");
}
/*
=======
finaliza
Realiza qualquer procedimento de limpeza para finalizar o jogo
=======
*/
void finaliza() {
clear_keybuf();
destroy_bitmap(buffer); // desaloca o buffer que utilizamos para o double buffer
// neste ponto voce devera adicionar qualquer tipo de finalizacao que for
// necessario, limpeza, etc.
}
/*
=======
atualizaTicker
Incrementa o contador de ticks de logica
=======
*/
void atualizaTicker() {
ticks++;
}END_OF_FUNCTION(atualizaTicker);
/*
=======
contaSegundos
Funcao executada uma vez por segundo para atualizar o contador de frames por segundo
=======
*/
void contaSegundos() {
totalFps = frames;
frames = 0;
} END_OF_FUNCTION(contaSegundos);
Valeu pessoal, até a próxima.
março 14th, 2009
Quando escrevemos um programa em C ou C++, por serem linguagens fortemente tipadas é necessário ter uma noção de quanto espaço cada tipo de dado pode ocupar, assim podemos ter uma noção para melhorar a eficiência do código.
Utilizando o programa abaixo, é possível conferir na máquina em que ele será compilado o tamanho de cada tipo de dado do C (bem como seus valores mínimos e máximos).
#include <stdio.h> // biblioteca de entrada e saida padrao
#include <limits.h> // biblioteca que contem os macros (definidos pelo fabricante do compilador) com os valores maximos e minimos suportados pelo mesmo
int main(int argc, char *argv[])
{
// total de bits do processador em que o programa foi compilado
char totalBits = sizeof(int) * 8; // geralmente o tamanho do tipo inteiro eh igual a quantidade de bits de processamento do processador
printf("\n\nMaquina de %d bits\n\n", totalBits);
printf("Tipo em C\t\tTamanho\t\t\tValores\n");
printf("=======================================================\n");
// caracteres
printf("char\t\t\t%d bytes (%d bits)\tsigned (%d a %d) unsigned (0 a %d)\n", sizeof(char), sizeof(char) * 8, SCHAR_MIN, SCHAR_MAX, UCHAR_MAX);
// valores inteiros
printf("int\t\t\t%d bytes (%d bits)\tsigned (%d a %d) unsigned (0 a 0x%X)\n", sizeof(int), sizeof(int) * 8, INT_MIN, INT_MAX, UINT_MAX);
printf("short int\t\t%d bytes (%d bits)\tsigned (%d a %d) unsigned (0 a %d)\n", sizeof(short int), sizeof(short int) * 8, SHRT_MIN, SHRT_MAX, USHRT_MAX);
printf("long int\t\t%d bytes (%d bits)\tsigned (%d a %d) unsigned (0 a 0x%X)\n", sizeof(long int), sizeof(long int) * 8, LONG_MIN, LONG_MAX, ULONG_MAX);
// numeros em ponto flutuante
printf("float\t\t\t%d bytes (%d bits)\n", sizeof(float), sizeof(float) * 8);
printf("double\t\t\t%d bytes (%d bits)\n", sizeof(double), sizeof(double) * 8);
system("PAUSE");
return 0;
}
Saber os tipos de dados e tamanhos pode servir por exemplo para se descobrir qual o menor tipo de dados na máquina utilizada ou a diferença entre dois tipos facilitando assim a escrita de um código mais otimizado.
Possui alguma dica interessante? Não deixe de compartilhar.
janeiro 5th, 2009
Página 1 de 15 1 2 3 4 5 » ... Último »
