Archive for the ‘Game Development’ Tag

Game Developers Conference 2009

Bom galera, estamos a meio do ano e, como sempre, começo minhas preparações financeiras e de calendário para a próxima GDC. Muitos já me perguntaram informações sobre como ir, quanto custa, etc, então decidi postar algumas informações do eventos, assim como algumas curiosidades, aqui.

Existem várias GDC durante o ano, incluindo San Francisco-CA, Paris e Austin-TX. Eu costumo ir na de San Francisco, e 2009 não será exceção.Vou falar rapidamente de valores, e depois vou explicar detalhadamente como funciona o evento, e algumas experiências próprias.

A GDC acontece no Moscone Center em São Francisco, Califórnia. Em termos de valores, não fica uma viagem barata para brasileiros. Porém, eu considero muito importante. Se aprende muito, se conhece muitas pessoas diferentes e sempre saio de lá com bons contatos. A viagem+hospedagem costuma sair por volta de 6 mil reais, mas eu costumo ficar em algum hotel na proximidade, que são ligeiramente caros (de 150 a 250 dolares a noite). Tem no entanto alguns albergues na região (inclusive sei de um perto do hotel Grand Hyatt, umas 4 quadras do Moscone Center) nos quais voce consegue uma semana por valores proximos a 500 dolares.

Em relação ao evento em si (que também é caro), existem vários tipos de passes. Geralmente eu pego o “All Access Pass”, que me permite participar de todos os tutoriais, eventos, palestras, keynotes, etc. Esse costuma ficar por volta de US$1500 com desconto de pagamento adiantado, ou US$2000 depois de janeiro. Existem outros passes mais baratos, incluindo o “Main Conference Pass” (US$1400 sem desconto), GDC Mobile Pass (US$1050 sem desconto), e “Expo Pass” (US$ 200). A cada ano, passes diferentes são criados ou somem, então é geralmente interessante dar uma boa olhada na lista antes de decidir (no primeiro ano, fui com um passe especial de “Independent Game Summit”). Esses preços incluem almoço nos dias correspondentes.

Falando um pouco da conferência agora. A GDC é na verdade o conjunto de vários eventos simultâneos. Segunda e terça são voltados para negócios e profissionais. Envolvem vários ‘summits’ (pequenos eventos), com palestras e atividades específicas a certas áreas do desenvolvimento de games. Por exemplo, a GDC Mobile, voltada para desenvolvimento de jogos para portáteis, Independent Game Summit, voltado para a comunidade de desenvolvedores independentes, etc. Acontecem também sessões de tutoriais e workshops de durações que vão de 1 hora até os 2 dias. Na de 2007, eu participei dos workshops de Game Design, e posso dizer que foram muito interessantes e divertidos.

De quarta até sexta, a chamada “main conference” acontece. Nesses dias, a feira com os stands das empresas e universidades é aberta aos participantes. É muito interessante tirar um par de horas para passear calmamente pela exposição, tem bastante coisa interessante. Como nota de interesse, este ano teve um pequeno concurso de programação de IA no stand da Microsoft, achei muito bacana. Em outro bloco, existe outra “feira” com stands – o Pavilhão de Carreira. Ali, voce pode conversar com o pessoal de RH, e as vezes representantes das diferentes áreas das empresas. Se voce pretende seriamente passar pelo pavilhão com intensões de arrumar uma possibilidade de emprego, leia as dicas no final deste post. Ao mesmo tempo que existem os dois pavilhões de exposição e carreira (acredite, acontece tanta coisa ao mesmo tempo que é facil se sentir perdido), acontecem as palestras. São um volume monstruoso de palestras , geralmente com várias da mesma área (programação, audio, design gráfico, game design, etc) acontecendo simultaneamente. E acredite, voce terá que escolher e não será facil. De novo, algumas dicas no final ajudam um pouco essa questão.

Acontecem também keynotes (alguem importante dando sua visão sobre algo), que eu recomendo dependendo do palestrante. Eu tive a honra de participar da keynote do Ray Kurzweil sobre os proximos 50 anos da indústria de jogos. Além disso, todo ano tem o evento/festa de premiação da IGF (Independent Game Awards), que reconhece os melhores jogos independentes do ano (o pessoal que criou Portal veio da cena independente). Depois, no mesmo evento, tem as premiações para os melhores jogos “normais” do ano – a Game Developer’s Choice Awards. É um evento muito interessante de participar, e eu provavelmente estarei lá ano que vem.

Paralelamente a tudo isso, existem pequenos eventos e festas acontecendo o tempo todo. Desde a tradicional festa da IGDA (International Game Developers Association), para participar voce deve ser membro (custa 100 dolares por ano). Tem também diversas festas patrocinadas pelas grandes empresas como Microsoft, Sony, etc. Muito importante estar atendo à programação do evento para saber escolher o que quer fazer (um LIVRO com grossura considerável que voce recebe ao se registrar no evento). Como uma curiosidade, este ano teve campeonato beneficiente de Poker, com custo minimo de 100 dolares. Eu participei e foi uma experiência incrivel. Além de tudo isso, a cidade de San Francisco oferece entretenimento e coisas pra fazer sem conta.

Dentro do Moscone Center costuma ser montada também uma pequena loja oficial do evento, vendendo desde camisetas até livros, DVDs, camisas, bolsas, canetas, esqueiros e o que mais voce possa imaginar. As coisas não são muito caras não, vale a pena comprar algumas lembrancinhas pra fazer inveja para seus colegas e amigos. Tem também todo ano uma especie de jogo interno ao evento que qualquer um pode participar. É um jogo focado em networking e me falaram que é bem interessante, porém nunca participei..hmm, quem sabe desta vez? rsrs

Bom, nao sei mais o que poderia falar do evento, então vou deixar aqui algumas dicas e informações:

Informações:

  • site oficial: www.gdconf.com (o site costuma ser atualizado mais perto do final do ano, é bom ficar ligado)
  • Data: 23 a 27 Março 2009
  • Local: Moscone Center, San Francisco – CA

Algumas dicas:

  • Tente chegar sabado ou domingo antes do evento. É bom para poder descançar, se habituar ao clima/horário, e poder encontrar pessoal antes do evento (caso combine algo) e mesmo passear um pouco pela cidade.
  • Mesmo para a hora de voltar pra casa. Tente passar pelo menos o sabado na cidade. Viajar para tao longe e nao poder conhecer a cidade decentemente é triste. De preferência e se tiver condições, pegue uma semana a mais porque realmente vale muito a pena.
  • Participe do máximo de festas e eventos noturnos da conferência. Se possível, vá com alguém (ou sozinho mesmo, acredite voce consegue puxar papo facil com pessoal de games) a algum dos bares da região. Um bar bastante badalado pelo pessoal da GDC é no hotel W (é do lado do Moscone Center). É uma ótima hora para socializar e fazer networking. Além do mais, é bom dar aquela relaxada tomando uma boa cerveja. Não precisa gastar muito pra beber e comer bem.
  • Não perca nenhum horário de palestra. Se realmente não tem nenhuma palestra interessante em algum horário (o que vai ser raro), aproveite esse tempo para fazer algo como visitar o pavilhão de exposição.
  • Seja simpático e comunicativo. Todo mundo ali tá com espírito de festa e diversão, quase certeza que se você puxar papo com o pessoal na sua mesa de almoço ou na descida da escada rolante, a pessoa vai conversar com você tranquilamente, e talvez até trocar cartões de visita.
  • Faça e leve cartões de visita. Se você trabalha em uma empresa, peça para seu chefe. Se recusarem ou simplesmente você ainda nao trabalha/não quer levar cartão da empresa – faça um pessoal. Um cartão apresentável com nome, profissão, email e telefone é obrigatório num evento como este.
  • Se voce pretende procurar oportunidades, faça um currículo padrão internacional e leve. Não precisa levar impresso, existem alguns locais baratos em que  você pode imprimir por lá. Se você nao pretende procurar oportunidade, leve seu currículo mesmo assim – nunca se sabe o que pode acontecer.
  • Tire o pó do seu inglês. É sério, se voce está na area de desenvolvimento de jogos, inglês é obrigatório. Se voce enrola no inglês, dê um jeito de desenferrujar. Se não sabe, tá numa boa hora de aprender já.
  • Leve dinheiro extra ou cartão de crédito com um bom limite. Você vai querer sair, comprar bugiganga, etc – se você for de grana contada vai perder oportunidade de se divertir melhor, e quem sabe de passar na BestBuy comprar aquela placa de vídeo ou então na Apple Store comprar seu iPod Touch ou MacBook (tem uma dessas a duas quadras do Moscone Center).
  • Ao se registrar no evento, você ganha uma entrada para o site de relacionamento do evento (MyGDC). Entre nele, fuce bastante, tente descubrir pessoas com interesses parecidos e puxe papo. O networking pode começar mesmo antes de ir!!
  • Se você tiver conhecidos pelo evento, tente saber que palestras eles vão participar. Não é muito interessante você ir numa mesma palestra que um conhecido seu – muito melhor vocês combinarem a ponto de cada um ir em uma palestra diferente, e depois trocar notas.
  • Leve (ou compre por lá) uma camera digital. Documentar sua viagem é muito importante!
  • No evento voce ganha uma sacola com presentinhos folhetos e outras coisas interessantes e uteis para o evento e depois. Não se acanhe de pegar o bloco e caneta que vem dentro e de anotar bastante durante as palestras. Sua memória pode ser infalível mas depois de dois dias durmindo 3~4 horas com palestras durante o dia e cerveja de noite, ela pode começar a lhe faltar.

Bom, agora nao consigo me lembrar de mais nenhuma dica. Se lembrar, eu posto hehehe.

Se algum de voces tiver dicas, informações ou simplesmente estiver pensando em ir e tiver interesse em se encontrar por lá, deixe um comentário. Se tiver dúvidas, quiser conversar sobre isso por msn/gtalk/email, ou quiser mais informações também é benvindo a colocar comentários ou me contatar.

Abraços pessoal!

Gerenciamento de conteúdo (parte 2)

No post passado demonstrei algumas funções para criação e leitura de um pacote de arquivos binários extremamente simples. Neste artigo, iremos colocar as funcionalidades explicadas lá numa classe, e fazer um pequeno gerenciador de conteúdo para que fique fácil recuperar imagens desse arquivo como surfaces SDL.

(NOTA: Pode acessar a parte 1 desta série AQUI)

Inicialmente, vamos olhar a definição da classe responsável por LER arquivos Pack:


class PackReader
{
private:
   FILE            *mFile;
   PackHeader      mHeader;
   PackFileEntry   *mEntries;

public:
   // construtor padrao
   PackReader() : mFile(0), mEntries(0) { }
   ~PackReader() { close(); }

   // abre/fecha arquivo
   void open ( const string &file_name );
   void close ();

   // pega surface SDL
   SDLSurface* getSurface ( const dword id );
};

E agora a implementação:


void PackReader::open ( const string &file_name )
{
   mFile = fopen(file_name.c_str(), "rb");
   if ( !mFile ) { /*ERRO*/ }

   // pega dados do arquivo
   fread(&mHeader, sizeof(PackHeader), 1, mFile);
   mEntries = new PackFileEntry[mHeader.numFiles];
   fread(mEntries, sizeof(PackFileEntry), mHeader.numFiles, mFile);
}

void PackReader::close ()
{
   if ( mFile )
   {
      fclose(mFile);
      mFile = 0;
   }
   memset(&mHeader, 0, sizeof(PackHeader));
   if ( mEntries )
   {
      delete[] mEntries;
      mEntries = 0;
   }
}

SDLSurface* PackReader::getSurface ( const dword id )
{
   if ( !mFile ) { /*ERRO*/ }
   if ( id >= mHeader.numFiles ) { /*ERRO*/ }

   // cria buffer de dados e le do arquivo
   byte *buffer = new byte[mEntries[id].size];
   fseek(pack, mEntries[id].offset, SEEK_SET);
   fread(buffer, sizeof(byte), mEntries[id].size, mFile);
   // transforma em RWOps
   SDL_RWops *rw = SDL_RWFromMem(buffer, mEntries[id].size);
   SDLSurface *surf = <span>IMG_Load_RW ( rw, 1 );</span>

   // apaga dados lidos e retorna imagem
   delete[] buffer;
   return surf;
}

Agora que temos a classe para ler os dados de forma encapsulada, vamos criar o nosso primeiro gerenciador.

Um gerenciador de conteúdo é responsavel por ler e controlar todo o conteúdo de um jogo. Este nosso gerenciador de exemplo vai nos fornecer métodos para ler e liberar surfaces SDL. Iremos nos aprofundar nele e no sistema de arquivamento ao longo dos artigos, implementando diversas técnicas e sistemas de apoio importantes. Por hora, vamos ver o básico:


// estrutura de apoio
struct SurfaceContainer
{
   SDLSurface *surface;
   int        refCount;
};

// o gerenciador em si
class ContentManager
{
private:
   // o nosso leitor de pack
   PackReader                     mPackReader;
   // este map vai conter os conteúdos já em uso
   map<dword,SurfaceContainer*>   mContent;

public:
   ContentManager();
   ~ContentManager();

   void init ();
   SDLSurface *getSurface ( const dword id );
   void releaseSurface ( const SDLSurface *surface );
};

A classe inclui apenas 3 métodos: init(), q vai inicializar o gerenciador, e os dois métodos para pegar e liberar surfaces. Vamos olhar rapidamente a sua implementação:


void ContentManager::init ()
{
   mPackReader.open("arquivo.pck");
}

SDLSurface *ContentManager::getSurface ( const dword id )
{
   // primeiramente, verificamos se já existe esta surface na memória
   map<dword, SurfaceContainer*>::iterator it = mContent.find(id);
   if ( it != mContent.end() )
   {
      // já temos essa surface. Incrementa contador e
      // retorna surface
      SurfaceContainer *container = it->second;
      container->refCount++;
      return container->surface;
   }

   // nao encontramos nenhuma surface, entao vamos ler do arquivo
   SurfaceContainer *container = new SurfaceContainer();
   container.surface = mPackReader.getSurface(id);
   // inicializar contador de referencia
   container.refCount = 1;
   // colocar no map
   mContent[id] = container;
   // e retornar
   return container.surface;
}

void ContentManager::releaseSurface ( const SDLSurface *surface  )
{
   // vamos procurar o container desta surface
   dword id;
   SurfaceContainer *container = 0;
   map<dword, SurfaceContainer*>::iterator it = mContent.begin();
   map<dword, SurfaceContainer*>::iterator itEnd = mContent.end();
   for ( ; it != itEnd; ++it )
   {
      if ( it->second->surface == surface )
      {
         id = it->first;
         container = it->second;
      }
   }

   // checar erros
   if ( !container ) { /*ERRO*/ }

   // decrementa contador e verifica se podemos remover da memoria
   container->refCount--;
   if ( !(container->refCount) )
   {
      mContent.remove(id);
      SDL_FreeSurface(container->surface);
      delete container;
   }
}

Pronto. Este gerenciador apenas controla surfaces SDL a partir de imagens estocadas no nosso arquivo Pack binário. O controle de uso é simples e com alta probabilidade de erro (ie. necessita que o programador lembre de liberar as surfaces), e seus algoritmos são ineficientes.

Porém, agora temos uma estrutura básica em cima da qual poderei explicar e implementar detalhadamente um sistema de empacotamento e gerenciamento de conteúdo de nível profissional. No próximo artigo, irei me aprofundar em algumas técnicas de empacotamento “reais”, para que a partir daí poderemos implementar um empacotador interessante, rápido prático e útil.

Até mais garotada!

Gerenciamento de conteúdo (parte 1)

Opa galera, após uma (extensa) ausendia da minha parte no blog, estamos de volta em ação!

Ultimamente estou trabalhando num pequeno projeto pessoal. Esse projeto consiste em uma biblioteca que permite juntar vários arquivos binários (imagens, sons, etc) num arquivo só, e os acessar através de um localizador.

Essa idea vem desde a época em que estava trabalhando na minha engine 2D (PaperCut). Passou por vários estágios, onde eu tentei me virar sozinho inicialmente, e depois comecei a pesquisar técnicas mais avançadas para a criação do tal sistema. Este post inicia uma série que vai retratar essa experiência e passar algumas ideas e dicas de como fazer um sistema assim.. Iremos começar bem simples, e depois ir elaborando por algumas técnicas e ideas eficientes até chegar num sistema avançado de gerenciamento de conteúdo para games.

Vamos começar?

Todo jogo hoje em dia tem algum tipo de sistema de gerenciamento de conteúdo (content ou assets). Esse gerenciador é responsável por gerenciar a leitura dos dados de arquivos (seja a cada abertura de fase, ou load-on-demand), liberação dessa memória quando os dados não são mais necessários, fazer cache e muitos até mesmo streaming. Todos eles incluem também algum sistema de empacotamento dos arquivos de dados do jogo. Alguns usam bibliotecas como zlib, e outros tem formatos complexos (MPQ da Blizzard, por exemplo). Vamos começar pelo sistema de empacotamento (e um bem simples).

O mais simples possivel que podemos fazer é (lol) simples. Basicamente, criamos um arquivo binário que vai conter algumas informações sobre os arquivos que ele contém, e esses arquivos copiados na integra em ordem. Os cabeçalhos de tal arquivo seria algo do genero:

( NOTA: neste artigo em específico nao estou utilizando POO por razões de simplicidade. Porém exemplos mais avançados quando começar a ficar mais complexo serão sim, orientados a objeto)


// cabeçalho do arquivo binario
struct PackHeader
{
   dword version; // guarda a versao do software de empacotamento
   dword numFiles; // numero de arquivos empacotados
};

// cabeçalho q define cada arquivo interno
struct PackFileEntry
{
   dword offset; // offset para o começo do arquivo interno
   dword size; // tamanho do arquivo interno
};

Mais simples impossivel haha. Inclui apenas o minimo de dados necessários: o numero de versao da biblioteca (sempre importante pois ao voce precisar alterar o formato do arquivo binario, pode facilmente manter retro-compatibilidade com outras versoes) e o número de arquivos empacotados.

Para criar o empacotador deste formato, nada mais simples:


dword packFile(FILE *outFile, string &inFileName)
{
   byte buffer[8192];
   dword bytes, size = 0;
   FILE *inFile = fopen(inFileName.c_str(), "rb");

   // copia conteudo de arquivo requesitado para dentro do pack
   while( !feof(outFile) )
   {
      bytes = (dword)fread(buffer, sizeof(byte), 8192, inFile);
      fwrite(buffer, sizeof(byte), 8192, outFile);
      size += bytes;
   }
   return size;
}
void packFiles( string &pack, vector<string> &files )
{
   // abre arquivo
   FILE *outFile = fopen(pack.c_str(), "wb");
   // cria cabeçalhos
   PackHeader header;
   header.version = 0x0001; // versao 1
   header.numFiles = files.count();
   PackFileEntry *entries = new PackFileEntry[header.numFiles];

   // escreve cabeçalhos
   fwrite(&header, sizeof(PackHeader), 1, outFile);
   fwrite(entries, sizeof(PackFileEntry), header.numFiles, outFile);

   // calcula o offset inicial para o primeiro arquivo
   dword currentOffset = sizeof(PackHeader) + (sizeof(PackFileEntry) * header.numFiles);

   // itera arquivos a incluir
   int i = 0;
   vector<string>::iterator it;
   vector<string>::iterator itEnd = files.end();
   for ( it = files.begin(); it != itEnd; ++it )
   {
      // seta o offset deste arquivo
      entries[i].offset = currentOffset;
      // empacota arquivo (seta tamanho)
      entries[i].size = packFile(outFile, *it);
      // atualiza offset
      currentOffset += entries[i].size;
   }

   // escreve de novo os cabeçalhos das imagens, pois eles foram atualizados com os offsets
   fseek(outFile, sizeof(PackHeader)+(sizeof(PackFileEntry*header.numFiles)), SEEK_SET);
   fwrite(entries, sizeof(PackFileEntry), header.numFiles, outFile);
}

// exemplo de uso
int main ( int argc, char **argv )
{
   vector<string> files;
   files.push_back("arquivo1.bmp");
   files.push_back("arquivo2.bmp");
   files.push_back("arquivo3.bmp");

   packFiles("arquivo.pck", files);
}

Com esse simples código criamos um arquivo binário (ao qual dei a extensao de pck, para Pack), que inclui os tres arquivos definidos no código. Sim mas , como os acessar agora? Todo sistema de empacotamento tem alguma forma de identificar e recuperar os arquivos empacotados. Geralmente usa-se uma string com o nome e caminho do arquivo, mas como estamos falando de algo extremamente simples, iremos usar identificadores numéricos. Tá mas, nao defini em nenhum lugar no código esses identificadores. Bom, neste exemplo, o identificador do arquivo é o número de ordem (com base 0 – zero), em que ele foi incluido. Então, o arquivo1.bmp teria identificador 0, o arquivo2.bmp seria 1 e por aí vai (como disse, extremamente simples). Vamos olhar rapidamente o código de recuperação dos arquivos.


byte *unpack(FILE *pack, dword id)
{
   // vai para posição do cebeçalho correta
   fseek(pack, sizeof(PackHeader) + (sizeof(PackFileEntry)*id), SEEK_SET);

   // le cabeçalho
   PackFileEntry entry;
   fread(&entry, sizeof(PackFileEntry), 1, pack);

   // cria buffer de leitura
   byte *buffer = new byte[entry.size];

   // vai para posição do arquivo interno
   fseek(pack, entry.offset, SEEK_SET);
   fread(buffer, sizeof(byte), entry.size, pack);

   // retorna buffer
   return buffer;
}

// exemplo de uso
int main ( int argc, char **argv )
{
   FILE *file = fopen("arquivo.pck", "rb");
   byte *bmp2 = unpack(file, 1);

   // faz algo com o bmp2
   algo(bmp2);

   // deleta
   delete[] bmp2;
}

De novo extremamente simples. Este sistema integra muito bem com o meu antigo post sobre leitura de surfaces SDL a partir de dados na memória.

Claro que este sistema nao inclui nada demais, e nao é sequer prático. Porém, a partir do próximo post, irei evoluir a idea exemplificada aqui até chegarmos num sistema prático, útil, flexivel que irá incluir coisas como encriptação e compactação, streaming, caching, etc.

Então crianças, não percam o próximo episódio!