FISL – Minhas Impressões

Olá, faz praticamente uma semana que voltei do meu segundo FISL. Sim, fui ano passado e fui esse ano novamente e pretendo ir ano que vem também!

Apesar do desastre da caravana, foi uma boa experiência. É um evento que vale a pena ir prestigiar, tanto pelas palestras quanto pelas pessoas.

Acredito bastante no futuro do software livre. Inclusive, minha futura empresa que UM dia abrirei, será baseada nessa filosofia.

Enfim..

Apesar de ter tido a impressão de que ano passado o nível das palestras estava mais alto, pude aproveitar bastante as que fui.

O Maddog palestrou duas vezes. Uma delas foi igual à do ano passado, sobre o projeto cauã. Apesar do projeto ter uma idéia BASTANTE interessante, ainda não conseguiu me convencer. Acho que será difícil convencer as pessoas a aderirem à nova tecnologia, mas estou torcendo FORTEMENTE para que dê certo.

Nota-se também uma crescente no investimento em software livre. Empresas apresentaram propostas para financiar idéias, fornecendo dinheiro e mão de obra. Isso é MUITO animador!

Algumas palestras simplesmente não prestaram. Ou o palestrante passava a impressão de não ter perícia no assunto, ou por ser simplesmente decepcionante porque espera-se uma coisa pela descrição da palestra, mas acaba que o foco é outro. Outras foram simplesmente maravilhosas. Tive a oportunidade de ir em palestras não técnicas também, foram incríveis! [ Game software livre e regulação ] Palestrante com domínio do assunto, bem preparado e sabendo como entreter o público alvo, nós x)

Teve uma sobre games que eu achei interessante [ técnicas 3d para reiventar o 2d ]. Apesar da palestra ter sido bastante ruim, o palestrante apresentou uma coisa que eu não sabia. Que é apresentar efeitos 3D bastente convincentes em jogos 2D, usando iluminação por normal. Fiquei bastante empolgado com o efeito xD

Voltei bastante satisfeito com o Evento. Valeu muito a experiência. Dias inesquecíveis!

FISL 11, eu fui

FISL – Caravana FAIL

Tinha tudo planejado. Arrumado a mala, escolhido algumas palestras, feito um lanche, e ido pro local de encontro.

Fui o primeiro a chegar, no horário, uma hora antes como solicitado. Em seguida e devagar chegou o resto. Todos presentes no local com até meia hora de antecedência. Todos, menos o ônibus. Acontece que a organização não prestou atenção na devida burocracia e portanto o ônibus não poderia levar o pessoal! Decepção geral, todos voltam para suas casas de cabeça baixa e com esperança de que no dia seguinte tudo se resolva e possamos ir para Porto Alegre finalmente.

Chato isso ter acontecido. Perdemos um dia de FISL e várias palestras interessantes. Uma pena. Espero que isso se resolva e possamos desfrutar os dias restantes pelo menos.

:/

TowerDefense Game

Jogos no estilo “TowerDefense” são bastante interessantes. Eles são um ‘subtipo’ do estilo estratégia de tempo real. Fizeram muito sucesso, por sua jogabilidade fácil e intuitiva, e por ser divertido, claro. Atingiu o ápice da fama com a internet e os jogos em flash.

O objetivo desse tipo de jogo é impedir que os inimigos cumpram determinado trajeto. Para isso deve-se posicionar torres, que atacarão os inimigos, estrategicamente.

Existem diversas versões, que pouco diferensiam-se entre si. Você pode encontrar algumas aqui:

• http://www.towerdefence.net/
• http://www.playtowerdefensegames.com/
• http://www.hebertphp.net/wordpress/?p=675

O gênero tower defense ficou bastante conhecido por causa de um mapa do Warcraft III,

mas foi idealizado bastante antes, na época do Atari com o jogo Rampart:

Hoje em dia, existe inúmeros clones feitos com flash – para web – os chamados desktop towerdefense, ou feitos para smartphones como iphone e android.

É divertido.

para saber mais:

http://www.loopinsight.com/2010/03/30/understanding-tower-defense-games/

http://en.wikipedia.org/wiki/Tower_defense

abraço [ ] .

Volta…

Olá..

Estive fora por muito tempo, bastante coisa mudou. Agora voltei pra ficar por mais um tempo pelo menos

Perdi meu foco no openGL, vou continuar postando alguma coisa sobre.. mas o foco mudou. Continuo com interesses em jogos, mas agora mais voltado para apis e engines prontas para usar, como a OGRE e a BULLET.

Estou desenvolvendo coisas interessantes com elas e espero poder postar algo bacana em pouco tempo por aqui.

abraço [ ] .

miniApp [1]

Oi.

Continuando com as miniapps, vamos discutir um modo para exibir Imagens. Usaremos texturas da opengl. Um simples tutorial pode ser encontrado no site do nehe. Contudo, abriremos uma imagem targa (tipo 2).

Criamos uma classe abstrata Image. Essa classe extende Drawable, tem um método para carregar uma imagem (loadImage) a partir de um path, e vários métodos para plotagem. Com esses métodos tem-se a opção de desenhar a imagem toda, ou uma subimagem, numa posição (x,y) qualquer, ou ainda desenhar a imagem ou sua subimagem, em uma posição relativa definida anteriormente – como a própria opengl faz.

Definimos uma classe derivada a partir da Image, chamada OpenglImage. Basicamente trata aspectos da textura em opengl.  Ela tem, protegidos, os dados da imagem (image), o tamanho (width, height) o formato (format) e o tipo (type), esses dados são necessários para o método que usaremos na implementação. Os scalares, usados para todas as imagens – portanto static,  estão aqui para manter o aspecto, a proporção, das imagens com relação às dimensões da tela em questão. Implementa as formas de plotar a imagem, mas não o modo de carregar – este é específico para cada formato. Em openGL cada textura tem um ID, que pode ser gerado por uma função da própria opengl.

O TargaImage extende a OpenglFormat e também o TargaFormat. O parpel dessa classe é simplesmente implementar o modo de abrir as imagens. Carrega os dados da imagem targa e seta as informações requeridas pelo OpenglFormat.

O TargaFormat já foi discutido nesse blog (nesse post). Serve apenas para obter os dados da imagem, simples assim.

Na miniApp declaramos uma imagem (OpenglImage) e criamos, no inicializador – método initialStartup, uma imagem TargaImage:

image = new myOpengl::TargaImage("exemplo.tga");

Então mandamos desenhar no método draw. Devemos ver a imagem exemplo.tga no centro da tela. Brinque à vontade com o exemplo. À bastante coisa que pode ser modificada. Por exemplo: Transparência – com o canal Alpha na imagem, pode-se “excluir” uma cor por exemplo, com bending, Cores – mude o imageData, trocando cores, posicionamento, tente abrir outro formato, tente “flipar” a imagem, tente aumentar o brilho… Várias coisas para “brincar”

Entendendo a textura do Opengl, a implementação da classe OpenglImage.

No construtor geramos um (apenas 1, poderia ser mais) id usando a função : glGenTextures(1,&textureId); Linkamos, assim, um id qualquer à variável textureId.

Fazemos uma ligação daquele id com um parâmetro da opengl glBindTexture(GL_TEXTURE_2D,textureId); O parâmetro quarda informações importantes. Setamos algumas configurações em GL_TEXTURE_2D.

Posicionamos a textura de acordo com os vértices do “retangulo”.

Na classe TargaImage, quando abrimos a imagem, usamos a função glTexImage2D para passar as informações – data, tamanho, formato, tipo…

Antes de desenhar, ligamos novamente o id ao parâmetro, então “desenhamos”, na verdade formamos um quadrado, no qual conterá a imagem.

Molezinha.

Ah! O BaseOpengl talvez esteja um pouco diferente dos outros posts para poder usar o canal alpha.

O projeto está no repositório: https://svn.inf.ufsc.br/matheus.zeroth/miniApp/exemplo2/

:p

miniApp [0]

Começando a publicar miniApp com o intuito de aprender um bucadinho com pouquinho, aplicações simples e pequenas com o objetivo bastante direto. Vamos começar com os tutoriais do nehe.

O primeiro é bastante simples. Vamos usar a nossa classe BaseOpenGl, já discutida. Iremos implementar uma classe miniApp que deve chamar o método draw das classes triangulo e quadrado. Essa app irá simplesmente desenhar 2 objetos na tela.

Usaremos uma classe [tosquinha à princípio, apenas para seguir a filosofia orientada a objetos] chamada Coordinate [coordinate.cpp coordinate.h]. Essa classe possui os vetores x, y, z. Terá o papel de posicionar os objetos na tela.

As classes do triangulo e do quadrado implementam o método virtual ‘draw’ da classe Drawable.

A classe Cor [cor.h cor.cpp] apenas abstrai as cores red, green, blue. Ou seja, ‘encapsula’ três variáveis. Novamente, apenas seguindo a filosofia.

O main terá este corpo:

#include <GL/glut.h>

#include "miniApp.h"

int main (int argc, char** argv)
{
    glutInit(&argc,argv);

    MiniApp app;
    app.startOpenGL(640,480,"miniApp");

    glutMainLoop();

    return 0;
}

O triângulo será isóceles – acho que é isso. Apenas a posição relativa ao seu centro mudará, terá tamanho unitário fixo. O quadrado seguirá a mesma idéia. Ambos derivarão de uma classe chamada GeometriaGl [geometriagl.h geometriagl.cpp], uma classe que extende drawable e trata a ‘position’ e a ‘Cor’.

A classe GeometriaGl deve ter um cabeçalho mais ou menos assim:

#ifndef _GEOMETRIA_
#define _GEOMETRIA_

#include "drawable.h"
#include "coordinate.h"
#include "cor.h"

class GeometriaGl: public Drawable{
 protected:
     Coordinate _position;
     Cor* corVertice;
 public:
     GeometriaGl(int vertices,Coordinate initialPosition);
     void position(Coordinate newPosition);
     Coordinate position();

     void cor(int,Cor);
     void cor(Cor);
};

#endif

Portanto na classe MiniApp [miniApp.h miniApp.cpp] Teremos ponteiros para a classe GeometriaGl, os quais irão transformar-se no triangulo e no quadrado posteriormente – quando a classe for criada (não esqueça de destruí-los).

Agora vamos discutir o foco do tutorial do nehe, o método draw das classes TrianguloGl [triangulogl.h triangulogl.cpp] e QuadradoGl[quadradogl.h quadradogl.cpp], assim como os métodos de transformação. (Obviamente, como já deve ter percebido, o projeto está no repositório, com nome de exemplo1, [svn.inf.ufsc.br/miniApp/] e pode ser pego via svn).

triagulo source, método draw:

void TrianguloGl::draw(){
glPushMatrix();

glTranslatef(_position.x(),_position.y(),_position.z());

glBegin(GL_TRIANGLES);
glColor3f(corVertice[0].r(),corVertice[0].g(),corVertice[0].b());
glVertex3f( 0.0f, 1.0f, 0.0f);
glColor3f(corVertice[1].r(),corVertice[1].g(),corVertice[1].b());
glVertex3f(-1.0f,-1.0f, 0.0f);
glColor3f(corVertice[2].r(),corVertice[2].g(),corVertice[2].b());
glVertex3f( 1.0f,-1.0f, 0.0f);
glEnd();

glPopMatrix();
}

quadrado source, método draw:

void TrianguloGl::draw(){
glPushMatrix();

glTranslatef(_position.x(),_position.y(),_position.z());

glBegin(GL_TRIANGLES);
glColor3f(corVertice[0].r(),corVertice[0].g(),corVertice[0].b());
glVertex3f( 0.0f, 1.0f, 0.0f);
glColor3f(corVertice[1].r(),corVertice[1].g(),corVertice[1].b());
glVertex3f(-1.0f,-1.0f, 0.0f);
glColor3f(corVertice[2].r(),corVertice[2].g(),corVertice[2].b());
glVertex3f( 1.0f,-1.0f, 0.0f);
glEnd();

glPopMatrix();
}

Para desenhar um geométrico em OpenGL é necessário dizer que começará o desenho e qual o tipo. glBegin() cuida disso. Sempre que começar a desenhar (glBegin) é preciso terminar com glEnd(). No parâmetro passamos o tipo de geometria que estamos interessados. Em seguida do begin passamos os vértices. De três em três para o triângulo (GL_TRIANGLES) e quatro em quatro para o quadrado (GL_QUADS). Bastante simples.

O glPushMatrix(), serve para guardar numa pilha o estado atual da matriz. No caso, usamos para guardar a ‘posição’ atual da “cena”. Usamos o glPop() para restaurar as configurações.

Pode-se montar uma pirâmide com os triângulos ou um cubo com os quadrados apenas posicionando-os lado a lado. 4 triangulos formam uma pirâmide e quadro quadrados formam um cubo

Faça de exercício, se precisar colar: http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=05

Bem por cima, é isso. Não sou muito bom em escrever ¬¬    Mas melhorarei xD

Pegue o código no svn, ele é bem auto-explicativo.

TRIANGLES

BaseOpenGL

Vamos implementar uma classe chamada BaseOpenGL – classe para iniciantes, que tem por finalidade facilitar a utilização das funções básicas da biblioteca OpenGL.

A idéia é que seja possível implementar apenas os métodos interessantes numa classe derivada. E que com a classe implementada possamos dar um simples start.

Da maneira que implementei, foi preciso usar uma roupagem para contornar os métodos da opengl que usam callbacks.

Para entendimento das funções básicas, sem preocupações com a orientação à objetos sugiro o material da ufsc, ou do nehe

Vamos aos métodos Públicos:

BaseOpenGL();

 virtual int startOpenGL(int,int,const char*);
 virtual void glEnable2D();
 virtual void glDisable2D();

 inline int getWidth();
 inline int getHeight();
 inline int getWindowNumber();
 inline std::string getTitle();

 virtual ~BaseOpenGL();

O método startOpenGL, criará a janela da opengl com o tamanho (widthxheight) determinado pelos inteiros passados e com título da janela definido pela string passada. Inicia a glut, seta algumas variáveis, configura as funções callbacks, e retorna o valor da função initGL.

As funções glEnabled2D() e glDisable2D(), abilitam e deabilitam, respectivamente, a opengl para trabalhar com 2D.

As funções seguintes são autoexplicativas e tem como objetivo o acesso a algumas variáveis.

-

Os métodos protegidos devem ser:

protected:
 virtual int  initGL();

 virtual void draw(void) = 0;
 virtual void idleDraw(void) = 0;
 virtual void reshapeWindow(int,int) = 0;
 virtual void keyBoardEvent(unsigned char,int,int) = 0;
 virtual void specialKeyBoardEvent(int,int,int) = 0;

 virtual void initialStartup();

 static BaseOpenGL* reference;

 std::string title;
 int width;
 int height;

Sendo que as funções abstratas serão aquelas que devem ser implementadas numa classe posterior.
initGL deve fazer as pré-configurações e retornar “verdadeiro” se estiver tudo ok.
initialStartup deve ser implementada se o usuário quiser mudar ou acrescentar alguma configuração inicial.
A variável title é o título da janela, width e height, é o comprimento e a altura da janela.

‘reference’ é a roupagem. Esta variável deve apontar para a classe que está implemendo os métodos abstratos.

Portanto há um porém: No construtor – ou em algum outro lugar – da classe derivada, deve-se fazer com que o ponteiro reference aponte para ela. Algo semelhante à:

ClasseDerivada::ClasseDerivada(){

BaseOpenGL::reference = this;

}

-

Nos métodos privados temos as funções que irão preencher os callbacks e o número da janela:

int window;

 static void reshapeFunc(int,int);
 static void displayFunc(void);
 static void keyboardFunc(unsigned char tecla, int x, int y);
 static void specialFunc(int tecla, int x, int y);
 static void idleFunc(void);

e aqui encontra-se a implementação.
e aqui o cabeçalho.

Usaremos esta classe para implementar algumas coisas em opengl mais à diante.

É fácil usar, basta extender uma classe à partir da BaseOpenGL, implementar os métodos abstratos.
E no main do seu programa pode fazer algo parecido com isto:

#include <GL/glut.h>

#include "programaEmOpengl.h"

int main (int argc, char** argv)
{
glutInit(&argc,argv);

Programa p;
p.startOpenGL(640,480,"General");

glutMainLoop();

return 0;
}

//pronto.

(Projeto)General – Introdução

Vamos começar a desenvover um joguinho simples baseado no poker, conhecido como General.

O jogo: São 5 dados, que devem ser combinados para poder pontuar em algum ‘jogo’ da sua cartela. Se já não há possibilidade de marcar pontos com o que os dados mostraram, então deve-se ‘queimar’ algum que ainda nao foi marcado. Cada jogador tem a possibilidade de jogar 3 vezes os dados. De modo que em qualquer jogada pode marcar seus pontos, mas na última é preciso, efetivamente, marcar. Ganha o que conseguir maior pontuação.

Na primeira jogada de cada rodada de um jogador deve-se jogar todos os cinco dados. Depois da primeira jogada pode-se escolher quais dados serão relançados à fim de conseguir uma melhor combinação. Quando conseguir uma combinação interessante ou terminada a jogada deve-se marcar os pontos na Cartela, mas lembre-se: pode marcar apenas uma vez em cada tipo de ponto. Portanto deve-se escolher sabiamente

Referência[1]:http://www.math.cornell.edu/~mec/2006-2007/Probability/Yahtzee.htm

Referência[2]:http://pt.wikipedia.org/wiki/General_(jogo)

A Cartela deve ser algo assim [2]:

• Jogada de 1: um certo número de dados (de 0 a 5) marcando o número 1; sendo que a jogada vale mais pontos conforme a quantidade de dados que marcarem o número 1. Por exemplo: 1-1-1-4-5 vale 3 pontos.
• Jogadas de 2, 3, 4, 5 e 6: correspondentes à jogada de 1 para os demais números. Por exemplo: 3-3-4-4-5 vale 6 pontos se for considerada uma jogada de 3; ou 8 pontos se for considerada uma jogada de 4; ou ainda 5 pontos se for uma jogada de 5.
• Trinca (T): três dados marcando o mesmo número. Vale a soma dos 5 dados. Exemplo: 4-4-4-5-6 vale 23 pontos.
• Quadra (Q): quatro dados marcando o mesmo número. Vale a soma dos 5 dados. Exemplo: 1-5-5-5-5 vale 21 pontos.
• Full-hand (F) ou Full-house: uma trinca e um par (exemplo: 2-2-2-6-6). Vale 25 pontos para qualquer combinação.
• Seqüência alta (S+): 2-3-4-5-6. Vale 30 pontos.
• Seqüência baixa (S-): 1-2-3-4-5. Vale 40 pontos.
• General (G) ou Yam: cinco dados marcando o mesmo número (por exemplo: 4-4-4-4-4). Vale 50 pontos.
• Jogada aleatória (X): qualquer combinação. Vale a soma dos 5 dados. Por exemplo: 1-4-4-5-6 vale 20 pontos.

A partir desse ponto, que já conhecemos mais ou menos como será o projeto podemos dar início às implementações. Começaremos implementando algumas classes, depois faremos com que o jogo rode via texto, e prosseguiremos com mais idéias. O objetivo é terminar com ele implementado em opengl e com possibilidade de rodar pela internet!

Sprite – implementação

Vamos supor, primeiramente, a existência de uma interface para imagens. Essa deve pelo menos poder fazer clipping da imagem. Mais ou menos assim:

/*drawable.h*/

#ifndef _DRAWABLE_
#define _DRAWABLE_

class Drawable{
       public:
              virtual void draw()=0;
};

#endif

/*image.h*/
/*
veremos como implementar uma imagem em opengl posteriormente.
pode ter mais manipulação também como flips e troca de cores por exemplo.
*/

#ifndef _IMAGE_
#define _IMAGE_

#include <string>
#include "drawable.h"

class Image: public Drawable{
      public:

/*para carregar os dados da imagem*/
            virtual void loadImage(std::string path)=0;

/*desenhar os dados na tela diretamente*/
            virtual void draw()=0;

/*desenhar na tela na posição x e y passada*/
            virtual void draw(const float x, const float y)=0;

/*desenhar diretamente na tela a imagem clipada pelo retangulo passado*/
            virtual void draw(int startX, int startY,int subheight, int subwidth)=0;

/*desenhar na posicao passada a imagem clipada pelo retangulo passado*/
            virtual void draw(const float x, const float y,int startX, int startY,int subheight, int subwidth)=0;
};

#endif

Bom, considerado isso e a definição de sprite visito num post anterior, vamos começar a construir o sprite para nosso futuro jogo.

Ok, nosso sprite precisa conhecer as dimensões da imagem. Não o tamanho real dela, não o tamanho do arquivo (*.bmp, *.tga, *.jpeg, etc), e sim o tamanho que ela deve aparecer no jogo, o tamanho da subimagem. Chamaremos de width e height e serão do tipo inteiro.

Talvez queiramos saber também se o sprite é desenhável. Porque, caso o ‘personagem’ seja destruido, não vamos mais ter interesse em desenhá-lo na tela, por exemplo. Então devemos ter um booleano chamado ‘drawable‘ que checaremos sempre antes de desenhar a imagem.

Não necessariamente precisamos saber a posição na tela onde o sprite será desenhado, já que em OpenGL por exemplo isso pode ser decidido (mudado) fora do sprite. Mas eu prefiro que tenha um ponteiro para alguma posição do objeto que está representando. Tomaremos o cuidado para que o sprite não interfira nessa posição. Chamaremos os ponteiros, obviamente, de x e y.

O coração do sprite será o grabimage. Onde recortaremos a imagem de acordo com o frame que se encontra. Nessa primeira implementação do sprite usaremos uma imagem apenas, na qual contém todas as subimagens necessárias, e cliparemos essa imagem em tempo real. Para tal usaremos os atributos width e height que já discutimos.

Usaremos StartX e StartY que indicarão em que posição começamos a clipar. Por exemplo, uma determinada linha da imagem pode significar que o personagem anda para a direita, e outra que ele ande para cima, então usamos essas variáveis para selecionar esses movimentos.

Columns, que é o número de colunas, geralmente representa a quantidade de movimento.

nFrames é a quantidade de frames que o movimento tem. Basicamente, quando chegar ao fim das colunas ele pulará para a próxima linha se tiver mais frames, ou não chegará ao fim das colunas se tiver nframes de menos. Tudo vai de acordo com o design da imagem selecionada.

frame, o frame corrente.

delay e count é usado para segurar o frame por um tempo baseado em ticks – ciclos do jogo.

então temos o ponteiro para image que é imagem que estamos tratando e da qual tiraremos as subimagens.

até agora deve estar mais ou menos assim:

/*sprite2d.h*/
class Sprite2D: public Drawable{
protected:
const float* const x;
const float* const y;

int width;
int height;
int startX, startY;
int columns, nFrames;
int delay, count;
int frame;
bool drawable;

Image* image;

};

Estando claro isto famos à função mais importante deste post:

inline void Sprite2D::grabImage(){
      imagePosX = startX + (frame%columns)* width;
      imagePosY = startY + (frame/columns)* height;
}

Com esta função poderemos pegar a imagem que precisar durante a execução do programa.
Adicionaremos/implementaremos mais três funções:

• draw() – desenha a imagem do frame atual
• update() – atualiza o frame atual
• render() – atualiza e desenha a imagem.

O arquivo cabeçalho ficará mais ou menos assim: (tem mais algumas frescuras à princípio desnecessárias, que eu achei que fossem ser necessárias para mim e resolvi não editar para postar aqui (: )

</pre>
#ifndef _Sprite2D_
#define _Sprite2D_

#include "drawable.h"
#include <string>

#include "image.h"

class Sprite2D: public Drawable{
private:
      int imagePosX, imagePosY;
protected:
      const float* const x;
      const float* const y;

      int width;
      int height;
      int offsetWidth, offsetHeight;
      int startX, startY;
      int columns, nFrames;
      int delay, count;
      int frame;

      bool drawable;

      Image* image;

      virtual void grabImage();

public:
      Sprite2D(Image*,const float* x,const float* y,int width,int height,
                 int nFrames,int colunms,int startX, int startY, int delay=15);
      virtual ~Sprite2D();

      virtual void render();
      virtual void update();
      virtual void draw();
      virtual void loadImage(std::string path);

      void setGrabStartX(int);
      void setGrabStartY(int);
      void setColumnsNumber(int);
      void setFramesNumber(int);
      void setDelay(int);
      void setFrame(int);
      void setDrawable(bool);
      void setImage(Image*);
      void setWidth(int);
      void setHeight(int);
      void setOffsetWidth(int);
      void setOffsetHeight(int);
      void turnDrawable();
      void turnOffDrawable();
      void clearDelayCount();
};
#endif

Eis o nosso sprite xD

Não deixairei sair daqui sem o arquivo implementado, é claro: sprite2D.h sprite2D.cpp image.h drawable.h

exemplo: exemplo.zip [breve]

Números Randomicos em C++

Usei estes dias, é mamão com açúcar, mas para quem não lembra:

Use srand() uma vez no seu código para gerar números REALMENTE aleatório. Caso contrário irá gerar sempre os mesmo números, o que é importante para debugar.

Use rand() para pegar um número pseudo aleatório qualquer. Aplique o operador ‘%‘ para determinar algum intervalo de 0 à um número qualquer.

exemplo – Gerar um numero aleatório de 30 à 100:

#include <cstdlib>
#include <ctime>
#include <iostream>

int main (int argc, char const* argv[])
{
      srand((unsigned)time(0)); //para gerar números aleatórios reais.
      int maior = 100;
      int menor = 30;
      int aleatorio = rand()%(maior-menor+1) + menor;
      std::cout << "Numero Aleatorio = " << aleatorio << std::endl;
      return 0;
}