RON PENTON sempre brincou com videogames.

A partir dos 11 anos, quando seus pais lhe

compraram seu primeiro livro de programação de jogos sobre como fazer jogos de aventura, Ron
sempre se esforçou para aprender mais sobre como os jogos funcionam e como criá-los. Ron é
bacharel em Ciências da Computação com especialização em Matemática pela Universidade
Estadual de Nova York em Buffalo. Ele escreveu dois outros livros, Data Structures for Game
Programmers e MUD Game Programming. Ron também contribuiu para o livro de Bruno de Sousa,
Game Programming All in One. Você pode ver o site pessoal de Ron em http://ronpenton.net.

Conteúdos de Relance
Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xvi
Parte I: Aprendendo C # 1
Capítulo 1 A História do C #. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3
Capítulo 2 O Básico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13
Capítulo 3 Uma Breve Introdução às Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
Capítulo 4 C # Avançado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Capítulo 5 Mais um capítulo c #. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .87
Parte II: Programação de Jogos em C # 121
Capítulo 6 Configurando um Framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
Capítulo 7 Direct3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145
Capítulo 8 DirectInput. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .197
Capítulo 9 DirectSound. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0,219
Capítulo 10 Juntando um Jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Parte III: Apêndices 285
Apêndice A Respostas às Questões de Revisão. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
Apêndice B Configurando o DirectX e o .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Contents – Conteúdo

Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xvi
Parte I: Aprendendo C # 1
Capítulo 1 A História do C #. . . . . . . . . . . . . . . . . . . . . . . . . .3
Uma breve história dos computadores. . . . . . . . . . . . . . . . . .3
Idiomas de máquina e montagem. . . . . . . . . . . . . . . . . . . . . 4
Portabilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Idiomas de alto nível salvar o dia. . . . . . . . . . . . . . . . . . . . . . 5
Portabilidade com máquinas virtuais. . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
.NET para o Rescue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Just In Time Compilation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Teoria da Redução. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
O futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Capítulo 2 O Básico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13

Por que você deveria ler este capítulo. . . . . . . . . . . . . . . . . . . . . . . . . . .13

Seu primeiro programa em C #. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
O ponto de entrada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Olá, c # !! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Compilando e executando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
O básico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Tipos Básicos de Dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Typecasts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Ramificação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23
se declarações. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Trocar Declarações. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Avaliação de curto-circuito. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Looping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
enquanto Loops. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
For Loops. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Loops do-while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Quebre e continue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Escopo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Capítulo 3 Uma Breve Introdução às Classes. . . . . . . . . . . . . . . . . . . . . . .35
Valores versus referências. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Tipos de valor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Tipos de referência . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Noções básicas de estruturas e classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Criando Classes e Estruturas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Diferenças entre estruturas e classes. . . . . . . . . . . . . . . . . . 40
Colocando Funções em Suas Classes e Estruturas. . . . . . . . . . . . . . 41
Construtores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Destrutores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Mais truques avançados de classe. . . . . . . . . . . . . . . . . . . . . . . . . . 48
As noções básicas de herança. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Membros estáticos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Propriedades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Enumerações. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Capítulo 4 C # Avançado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64
Criando Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Usando namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Alias de Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67
Polimorfismo Básico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Funções Virtuais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Abstração. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Polimorfismo e Funções. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .74
Um exemplo de matriz básica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
O que é uma matriz? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Inicialização Inline. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Referências versus valores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Herança e matrizes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Arrays multidimensionais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Outro tipo de loop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Cordas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .82
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .84
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Capítulo 5 Mais um capítulo c #. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .87
Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
Interfaces versus Classes Abstratas. . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Herança Múltipla. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Estendendo e combinando interfaces. . . . . . . . . . . . . . . . . . . . . . . . 93
Exceções. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .94
Fundamentos da Exceção. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Tópicos avançados de exceção. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Delegados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Criando um Delegado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Encaminhando Delegados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Coleções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . , 102
A lista de matrizes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Tabelas de hash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Pilhas e filas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Outras coleções. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Acesso a arquivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .107
Córregos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Leitores e Escritores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Fluxos de arquivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Números aleatórios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
Sementes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Gerando números. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Outras técnicas de geração. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Acima e além . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116
O pré-processador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Sobrecarga do operador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Listas de Parâmetros Variáveis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Código inseguro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Recursos do C # 2.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .117
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

Parte II: Programação de Jogos em C # 121

Capítulo 6 Configurando um Framework. . . . . . . . . . . . . . . . . . . . . . . . . . .123

Criando um projeto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
SharpDevelop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Visual C # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Estrutura do D3D do Visual C #. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
O Framework Avançado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .134
Você tem tempo? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Problemas com o temporizador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Alterações no Framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Capítulo 7 Direct3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145
Versões do DirectX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .146
Um dispositivo para dominá-los todos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .146
É tudo sobre apresentação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Buffers e troca de buffer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Criando um dispositivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
O gerente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Atualizando o Framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .154
Configurar um dispositivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
Manipulando Multitarefas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Realmente desenhando coisas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .159
Vértices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Definindo alguns vértices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Toques Finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
Cores e alfa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .163
Brincando com cores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Jogando com Alpha. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Outra demonstração. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Texturização e Outras Formas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .169
Texturização. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Outras formas de geometria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Demo 7.4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Sprites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .177
A classe Sprite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Tornando o código melhor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
Demo 7.5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Fontes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .190
Criando uma fonte do sistema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Texto de desenho. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Demo 7.6. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Capítulo 8 DirectInput. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .197
Teclados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .197
Criando um dispositivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Coletando Entrada por Polling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Ratos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Criando um mouse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Pesquisando um mouse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Dispositivos de Jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .201
Encontrar um dispositivo de jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
Criando um dispositivo de jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
Obtendo dados do eixo do joystick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Modificando Atributos do Eixo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
Mais dados de joystick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Demonstração 8.3: Joysticks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
Feedback de Força. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0,210
O Editor de Efeitos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Carregando efeitos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Jogando Efeitos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Parando Efeitos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Demonstração 8.4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0,216
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Capítulo 9 DirectSound. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0,219
O dispositivo de som. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0,219
Buffers de Som . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0,220
Tocando Buffers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Descrições de Buffer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Demo 9.1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Efeitos sonoros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Som em 3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Buffers 3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Tópicos 3D adicionais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . , 224
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Capítulo 10 Juntando um Jogo. . . . . . . . . . . . . . . . . . . . . . . . . . 227
Configurando um design. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
O gênero de jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . , 228
Decidindo como o jogo funciona. . . . . . . . . . . . . . . . . . . . . . . . . . . . . , 228
O universo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Os atores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Os dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . , 229
Naves espaciais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Armas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Projéteis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Poderes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Atributos Comuns. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Um novo framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231
Configurando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Opções do dispositivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Blocos de Dispositivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Verificadores de entrada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Joysticks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235
Estados do jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Mudanças de Estado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Um estado de amostra. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
A aula de jogos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Atirador de Espaço Genérico 3000. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Objetos de Jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Os estados para GSS3K. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
O estado da ajuda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
O estado do jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
Jogando GSS3K. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
O futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . , 279
Mundos 3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
Detecção avançada de colisão. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
Inteligência artificial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
Networking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Armazenamento Avançado. . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
O que você aprendeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Revise as perguntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Por si só. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Parte III: Apêndices 285
Apêndice A Respostas às Questões de Revisão. . . . . . . . . . . . . . . . . . . . . . 287
Capítulo 1: A História do C #. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
Capítulo 2: O Básico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288
Capítulo 3: Uma Breve Introdução às Classes. . . . . . . . . . . . . . . . . . . . .291
Capítulo 4: C # Avançado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
Capítulo 5: Mais um capítulo c #. . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Capítulo 6: Configurando um Framework. . . . . . . . . . . . . . . . . . . . . . . . . , 298
Capítulo 7: Direct3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0,299
Capítulo 8: DirectInput. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300
Capítulo 9: DirectSound. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301
Capítulo 10: Juntando um Jogo . . . . . . . . . . . . . . . . . . . . . . .301
Apêndice B Configurando o DirectX e o .NET. . . . . . . . . . . . . . . . . . . . . . . 303
O .NET Framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
O SDK do .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
Ambientes Integrados de Desenvolvimento. . . . . . . . . . . . . . . . . . . . . . , 304
DirectX gerenciado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . , 304
Configurando Referências. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . , 304
Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

Introdução

Apenas alguns anos atrás, todos programavam jogos em C. Não havia dúvidas sobre isso - se você
queria programar jogos de ponta, você o fazia em C. Claro, o C ++ estava por perto, mas era muito
“lento”. Os recursos avançados oferecidos pelo C ++ tiraram muito poder de processamento, e isso
era simplesmente inaceitável para um programador de jogos.
Com o tempo, os computadores ficaram cada vez mais rápidos e os videogames ficaram cada vez
maiores. Logo, as pessoas perceberam que os jogos estavam ficando grandes demais para serem
escritos em C. Quando os programas eram pequenos, o C era uma excelente linguagem para usar,
porque não havia necessidade real de muito gerenciamento em seu código. Uma pessoa poderia
escrever um programa e entender facilmente o que tudo fazia. Mas C se torna um problema quando
os programas ficam maiores; É muito difícil gerenciar um grande programa escrito em C. Não vou
me estender no porquê por aqui - se você já usou C, sabe por quê.
O C ++ corrigiu muitos problemas com o C, mas manter a compatibilidade retroativa foi um grande
problema e, como resultado, o C ++ acabou sendo uma das maiores mutações de linguagem
existentes. É também uma ótima linguagem, mas tem uma longa lista de falhas associadas a ela.
Costumava ser que seu computador estava desatualizado quase no mesmo instante em que você
saía da porta da loja de computadores com ele. Eu me vi atualizando minha placa de vídeo uma
vez por ano, facilmente; verdadeiros jogadores obstinados iriam atualizar duas ou até três vezes
por ano! As coisas não são mais assim. Meu computador está aqui há um ano e meio, e não toquei
no interior dele, exceto para adicionar um novo disco rígido.
Os computadores chegaram a um ponto em que são rápidos o suficiente para lidar com a maior
parte do tempo necessário, e realmente não há grandes benefícios em atualizar seu computador
para executar os jogos mais novos, porque os jogos mais recentes estão tão próximos atingindo a
qualidade fotorrealista de que grandes avanços não estão sendo feitos mais.
Não é de admirar que idiomas “lentos” como o C # e tudo o mais que faz parte do .NET esteja se
tornando popular novamente. Os idiomas gerenciados, como o C #, geram muito mais sobrecarga
do que os antigos, mas oferecem muito mais em termos de proteção. Por isso, é menos provável
que você faça bugs em seus programas, devido à maneira como o idioma é projetado. Claro, essas
linguagens têm mais poder de processamento para fazer mais verificações para você, mas as
pessoas estão percebendo que vale a pena no final, porque elas permitem que você faça jogos em
menos tempo, sem se preocupar com pequenas nuances.

Para quem é este livro

Este livro é para qualquer pessoa que queira aprender como programar em C # e DirectX 9. Você
não é obrigado a ter nenhum conhecimento de C # em tudo a fim de ler este livro, mas algum
conhecimento de programação (em qualquer idioma) seria útil.
Além disso, você não precisa sair nem comprar nenhuma ferramenta para acessar a programação
em C #, porque tudo que você precisa para programar em C # está disponível gratuitamente!
Examine o Apêndice B para obter mais informações sobre como configurar para programar em C
#.

Este livro não será um guia completo para C #, DirectX ou programação de jogos em geral.
Pretende-se simplesmente dar-lhe um impulso no tópico. Seria impossível oferecer um guia
completo para qualquer um desses tópicos em um livro deste tamanho (e seria impossível oferecer
um guia completo para programação de jogos em um livro de qualquer tamanho), então eu passei
por C # e DirectX e escolheu os tópicos fundamentais para cobrir, bem como outros tópicos que
são especialmente importantes para a programação do jogo.

Layout do livro

Este livro está dividido em três partes diferentes. Cada parte e capítulo é visualizado nas próximas
seções.

Parte I: Aprendendo C #
Esta seção do livro destina-se a dar uma boa olhada em como iniciar a programação em C #.

Capítulo 1: A História do C #
Você não pode entender bem nenhum conceito sem entender como ele surgiu, portanto, este
capítulo informa porque C # e .NET foram criados e como eles funcionam.

Capítulo 2: Noções Básicas

Este capítulo lhe dará uma olhada no seu primeiro programa C # e apresentará alguns conceitos
básicos de linguagem, incluindo tipos de dados, operadores matemáticos, variáveis, constantes,
conversões de tipo, lógica condicional e lógica de looping.

Capítulo 3: Uma Breve Introdução às Classes

As classes são os blocos básicos de construção de qualquer linguagem orientada a objetos. Este
capítulo abordará como criar classes, as diferenças entre tipos de valor e referência, coleta de lixo,
estruturas, funções, construtores, herança, tipos enumerados e propriedades.

Capítulo 4: Advanced C #
Depois de conhecer todos os conceitos básicos da programação em C #, este capítulo o levará
mais a fundo na selva, apresentando os conceitos de namespaces, polimorfismo, abstração e
estruturas básicas de dados.
Capítulo 5: Mais um capítulo C #
Este capítulo aborda todos os tópicos importantes que não foram abordados nos capítulos
anteriores, como interfaces, exceções, delegados, acesso a arquivos, números aleatórios e
estruturas de dados mais avançadas.

Parte II: Programação de Jogos em C #

Agora que você tirou todos os recursos básicos de C # do caminho, esta seção do livro apresentará
as noções básicas de como acessar o DirectX e criar um jogo de computador usando vários
componentes de vídeo, entrada e som.

Capítulo 6: Configurando um Framework

Há muita configuração necessária ao inicializar os vários componentes de um jogo. Este capítulo

descreve como criar um framework básico para iniciar seus projetos de jogos.

Capítulo 7: Direct3D

A programação gráfica é uma das partes mais complexas dos jogos atualmente, então não é
surpresa que este seja um dos capítulos mais longos do livro. Ele repassa o que você precisa saber
para criar um dispositivo Direct3D, buffers de retorno e formatos de exibição, bem como lidar com
multitarefas e como desenhar triângulos. Ele também abrange sombreamento de cores, mistura,
texturas, sprites e texto.

Capítulo 8: DirectInput

Obter entrada do usuário é uma parte essencial da programação de jogos, e este capítulo abrange
tudo, desde teclados até mouses e todos os dispositivos de jogo intermediários. Este capítulo
também cobre a programação de feedback de força.

Capítulo 9: DirectSound

O som é o principal componente final de mídia de um jogo. Neste capítulo, você aprenderá como
carregar e reproduzir sons do disco e poderá brincar com alguns dos recursos de programação de
efeitos e de programação de som 3D que o DirectSound oferece também.

Capítulo 10: Montando um Jogo

Neste capítulo final, você aprenderá como combinar o conhecimento que você ganhou em todos
os capítulos anteriores e programar um jogo real, o Generic Space Shooter 3000.

Apêndices
Existem dois apêndices neste livro.

Apêndice A: Respostas às Questões de Revisão

Cada capítulo tem perguntas de revisão no final, e este apêndice contém as respostas para essas
perguntas.

Apêndice B: Configurando o DirectX e o .NET

Este apêndice descreve como configurar os vários componentes que você precisará para
comece a programar seus jogos em c #.

Aqui vamos nós!

Você está pronto para começar a ler (e programar em C #!). Se você tiver alguma dúvida, ficarei
feliz em respondê-las; apenas me envie um e-mail para CSBook@ronpenton.net. Por favor, seja
paciente ao esperar por uma resposta - tenho muitos e-mails para responder diariamente e nem
sempre tenho tempo para atendê-los de maneira oportuna.

Você está pronto? É melhor você estar! Aqui vamos nós!

 Capítulo 1

A história do c #. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3
Capítulo 2
O básico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13
Capítulo 3
Uma Breve Introdução às Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
Capítulo 4
C # avançado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
capítulo 5
Mais um capítulo c #. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .87

Nesta primeira parte do livro, você aprenderá quase tudo que precisa saber sobre C # para começar
a programar seus próprios jogos. Obviamente, um livro deste tamanho não é possível cobrir todos
os tópicos C #, mas todas as coisas importantes são explicadas.

A história do c #
A história sempre foi um dos meus temas favoritos. Acho incrivelmente útil saber como e por que
os eventos aconteceram no passado. O conhecimento da história ajuda a explicar por que as coisas
são como são agora, e dá uma ideia de onde as coisas estão indo no futuro.

É por isso que, sempre que estou aprendendo uma nova tecnologia, tento descobrir primeiro a
história dessa tecnologia. isso me dá uma ideia de quais problemas foram projetados para resolver,
assim como quais problemas não podem resolver. Neste capítulo, você aprenderá:
Essas linguagens de máquina informam a um computador o que fazer.
Essas linguagens de montagem informam a um computador o que fazer em termos legíveis e
semelhantes aos humanos.
Como as linguagens de programação de alto nível permitem abstrair seus programas de linguagem
de máquina de baixo nível e descrevê-los de uma forma mais fácil.
Como as máquinas virtuais traduzem o código de máquina imaginário em código de máquina real.
Como as máquinas virtuais podem ajudar a portar programas para muitas plataformas facilmente.
Que todos os programas podem ser reduzidos em formatos de linguagem de máquina.
Que o .NET acelera o processo da VM traduzindo o código apenas na primeira vez
é executado.
Uma breve história dos computadores

Era uma vez, em uma terra mística distante, algumas pessoas loucas decidiram inventar a
matemática. É claro que, naqueles tempos, não existiam coisas como calculadoras ou
computadores, então as pessoas faziam matemática à mão, no papel. Como qualquer pessoa que
tenha aulas de matemática escolar sem uma calculadora pode atestar, isso não é nada divertido.
Além de realmente ter que usar o seu cérebro (o horror!), Sua mão pode facilmente ceder depois
de algumas centenas de cálculos.

Qual é a graça disso?

Para resolver o problema, algumas pessoas empreendedoras criaram a brilhante ideia de fazer
uma máquina que pudesse fazer cálculos matemáticos para você, sem todo o pensamento e escrita
incômodos. O homem criou o computador e viu que era bom. Agora não precisávamos esperar que
uma pobre alma realizasse algumas centenas de cálculos no papel; em vez disso, tínhamos uma
máquina que poderia fazer isso em muito menos tempo e com resultados completamente precisos.

Idiomas de máquina e montagem

Naqueles tempos antigos, os programas de computador eram simples. Alguns dos primeiros
computadores suportavam apenas oito comandos diferentes, no total, e só podiam executar
algumas dúzias deles antes que um novo programa tivesse que ser criado. Basicamente, um
programador fez uma lista de números, alimentou-o em um computador e o executou; os números
representariam os comandos.

Em um exemplo hipotético, o número 0 representaria um comando de adição e 1 representaria um

comando de multiplicação. Programas escritos assim são escritos em linguagem de máquina.

Com máquinas simples como os primeiros computadores, era fácil lembrar qual número significava
qual comando - afinal, havia apenas oito comandos ou algo assim. Eventualmente, no entanto, os
computadores se tornaram mais complexos. As pessoas começaram a adicionar mais e mais
comandos, de modo que em breve você tinha algumas dúzias, ou talvez até mais de uma centena
de comandos disponíveis. Pouquíssimas pessoas conseguem lembrar que muitos comandos, e
procurá-los em um manual o tempo todo, seriam muito entediantes, então as linguagens de
montagem foram inventadas. Uma linguagem de montagem é essencialmente uma linguagem que
traduz diretamente comandos baseados em palavras em linguagem de máquina. Por exemplo, na
máquina hipotética mencionada anteriormente, o código da linguagem da máquina para multiplicar
6 vezes 7 seria algo como isto:
1 6 7 em que 1 representa o comando e os dois números seguintes representam os dados. É claro,
olhar para impressões de centenas de linhas de números pode prejudicar seus olhos e seu cérebro,
então um comando de linguagem de montagem pode ser algo como isto: MUL 6, 7

Ah, agora isso é mais bonito para os olhos! Pelo menos agora você pode dizer imediatamente que
você quer
multiplique 6 vezes 7. Os computadores têm programas chamados assemblers, que tomariam o
código da linguagem de montagem e o traduziriam diretamente em código de linguagem de
máquina. Os montadores são programas muito simples; basicamente, tudo o que eles fazem é
encontrar o nome do comando e substituí-lo pelo número que representa o comando.

Portabilidade

Agora vamos falar sobre portabilidade. O termo portabilidade refere-se à capacidade de um

programa ser movido para outro computador. A portabilidade, até recentemente, era uma enorme
dor de cabeça. Você vê, havia muitas pessoas fazendo computadores nos velhos tempos, e quase
nenhum dos computadores trabalhavam juntos. Então, você teria uma máquina que entendia o
comando 1 como multiplicação, mas outra máquina usaria, digamos, 2 para indicar multiplicação.

Os idiomas de montagem ajudaram a resolver alguns desses problemas. Você poderia presumir
que a maioria das máquinas tinha os comandos básicos adicionar, subtrair, multiplicar e dividir,
então basicamente tudo que você precisava era um montador para a Máquina A para traduzir “MUL”
em 1, e um montador para a Máquina B para traduzir “MUL Em 2.
Teoricamente, você poderia portar um programa de montagem para muitas máquinas diferentes,
presumindo que cada uma dessas máquinas tivesse um programa de montagem que entendesse
a gramática de linguagem de montagem que você estava usando.
Mas as coisas ficaram feias rapidamente. Veja, os computadores tornaram-se bastante complexos,
e todas as empresas de computadores decidiram que queriam lançar o maior número possível de
comandos em um processador. Mas nenhuma das empresas poderia concordar sobre quais
comandos deveriam usar! Alguns computadores tinham comandos para executar matemática de
ponto flutuante, outros não. Alguns poderiam realizar cálculos com códigos binários (BCD) e outros
não. Ainda outros lhe deram uma dúzia de maneiras diferentes de acessar a memória, e outros lhe
deram apenas uma!

Nota__________________________________________________________________________
Não se preocupe com os cálculos do BCD; eles não são muito usados na programação de
jogos._________________________________________________________________________

Houston, nós temos um problema. Os montadores não podiam mais portar programas de uma
plataforma para outra porque as plataformas estavam se tornando uma bagunça confusa. Então,
ao invés de tentar criar programas para todas as máquinas, a maioria dos programadores aprendeu
a usar uma máquina e fez seus programas apenas para aquela máquina. Quer executar um
programa que foi feito para a Máquina A na Máquina B? Que infortúnio; isso não ia acontecer.
Idiomas de alto nível salvam o dia
Digite a linguagem de programação de alto nível, abaixo. Essas eram linguagens altamente
complexas que descreviam como realizar cálculos matemáticos, mas não abordavam todos os
detalhes confusos de como realizá-las.

Você poderia dizer algo assim: int i = 6 * 7;

Em uma linguagem como C (uma das primeiras e mais populares linguagens de programação de
alto nível), um programa chamado compilador pegaria esse texto e o traduziria para a linguagem
de máquina para você. Você realmente não precisa saber como isso acontece - tudo que você sabe
é que criou um número que armazena o resultado de 6 vezes 7.
Infelizmente, as linguagens de alto nível não conseguiram criar programas perfeitamente portáveis.
O problema é que cada compilador é diferente e faz as coisas de maneiras diferentes. Cada sistema
operacional tem uma API ( Application Programming Interface ), diferente que outras máquinas não
podem usar. Se você criar um programa do Windows, lidará com a API do WIN32, mas terá sorte
ao tentar fazer com que isso funcione em um Macintosh.

Portabilidade com Máquinas Virtuais

Então alguém teve a brilhante ideia de inventar uma máquina virtual (VM). Uma máquina virtual é
um processador de computador simulado em software. Por exemplo, digamos que você crie seu
próprio idioma de máquina. Isso é ótimo, mas se você não tiver seu próprio processador para
executar o idioma, será inútil. Então você vai em frente e cria um software que será sua máquina
virtual. Este software lerá as instruções da sua própria linguagem de máquina e as traduzirá em
instruções para o computador em que está sendo executado.

A figura 1.1 mostra esse processo.

Figura 1.1 Uma máquina virtual traduz instruções para serem executadas em uma máquina real.
Então, qual é o sentido disso? Por que não apenas escrever seu programa na linguagem de
máquina real em primeiro lugar? A resposta é portabilidade. Imagine se você pudesse sair e criar
VMs para dez plataformas diferentes. Agora você pode criar apenas um programa na sua
linguagem VM e executá-lo em dez máquinas completamente diferentes! A figura 1.2 mostra como
isso funciona. Uma das máquinas virtuais mais populares para atingir a indústria de computadores
foi a Java Virtual Machine (JVM), inventada para acompanhar a linguagem de programação Java.
A ideia era criar uma linguagem de computador que fosse executada em qualquer computador em
qualquer lugar - 100% de portabilidade. Isso permitiria que os desenvolvedores criassem um
programa e o vendessem em qualquer computador que tivesse uma JVM, sem ter que gastar
muitas horas e muito dinheiro tentando fazê-lo funcionar em outra plataforma. O lado positivo disso
é que os desenvolvedores instantaneamente tiveram acesso a um público-alvo muito maior. Seus
programas não funcionariam apenas em máquinas Windows, mas também funcionariam também
em máquinas Macintoshes e Linux, sem nenhum esforço extra de sua parte.

Figura 1.2 Você pode pegar um programa e executá-lo em diversas plataformas usando diferentes
máquinas virtuais (VMs).
Tudo isso soa excelente em teoria e Java tornou-se uma linguagem muito popular, no entanto,não
conseguiu se apossar da indústria de jogos de forma alguma. O primeiro problema, claro, é a
velocidade. Uma máquina virtual tem sobrecarga, o que significa que tudo tem que passar pela
máquina virtual antes que ela possa ser executada na máquina real. A programação de jogos, no
entanto, quase sempre se preocupou com a velocidade: todo mundo até o limite! Você quer pegar
o que você tem e apenas empurrá-lo o mais longe que puder. Ter uma máquina virtual no caminho
era um grande problema; Por que você programaria um jogo em Java que seria tão rápido quanto
um jogo que você poderia fazer em C ++? Obviamente, para jogos pequenos, e especialmente para
jogos baseados na Web, a velocidade não é realmente uma grande preocupação (e o Java
realmente decolou com aplicativos e jogos baseados na Web), mas para qualquer coisa realmente
grande, o Java não era nem uma consideração a se fazer.
Uma única língua não é a resposta para todos os problemas. Há momentos em que você quer
programar um jogo em uma linguagem como Java, mas outras vezes o Java simplesmente não
tem o que é preciso. Não vou aprofundar muito isso, mas existem idiomas inteiros por aí. que usam
paradigmas de programação completamente diferentes e são capazes de resolver problemas muito
mais facilmente (por exemplo, linguagens de programação funcionais como o LISP são bastante
usadas para programação de inteligência artificial) do que o Java pode. Não é uma boa ideia
amarrar um idioma a uma máquina virtual porque você está forçando as pessoas a programar em
um idioma que as pessoas talvez não gostem (e, acredite, há muitas pessoas por aí que não
suportam Java).

.NET para o resgate

Então vem o .NET. A Microsoft prestou muita atenção aos erros que a Sun cometeu com o Java e
tentou corrigi-los no .NET. Eles não conseguiram todos, mas, no geral, o .NET é uma grande
melhoria em Java e realiza muito do que o Java não conseguiu entregar.

A plataforma Microsoft .NET é essencialmente uma rede muito complexa de ferramentas que
engloba tudo, desde a segurança até a implantação da Web. A parte mais interessante do .NET,
no entanto, é o Common Language Runtime (CLR), que é uma máquina pseudo-virtual que executa
o código Microsoft Interpreted Language (MSIL). Eu vou entender o significado disso daqui a pouco.
O .NET não está vinculado a nenhum idioma em particular. A Microsoft suporta oficialmente quatro
.NET diferentes línguas:
C ++ gerenciado
C # (pronunciado ver-sharp)
Visual Basic.NET
J # (pronunciado jay-sharp)
Extraoficialmente, existem literalmente mais dúzias de linguagens que possuem compiladores que
geram código MSIL. Essas linguagens incluem LISP, PERL, Python e até mesmo (gasp) COBOL.

Cuidado
Como existem muitas linguagens que podem ser compiladas no .NET, e .NET tem acesso ao DirectX,
é teoricamente possível programar jogos em COBOL. Mas isso é algo que apenas profissionais
qualificados devem tentar; em outras palavras, não tente isso em casa, crianças. Você pode
machucar alguém.

A melhor parte do .NET, no entanto, é o fato de que tudo no .NET compartilha um layout similar,
chamado Common Type System. Basicamente, se você criar uma classe em um idioma (como o
Visual Basic), dar dois inteiros e compilá-los, você poderá criar a mesma classe em C # com os
mesmos dados e teoricamente deverá compilar no mesmo código MSIL.
Qualquer coisa que seja compilada no .NET pode acessar outros módulos .NET também, o que
tem o interessante efeito colateral de permitir que muitos idiomas diferentes se comuniquem. Por
exemplo, se você estiver usando o C #, poderá dizer a ele que use classes criadas no Visual
Basic.NET. Melhor ainda, você pode herdar deles e expandir suas capacidades, o que significa que
você pode ter aulas que foram criadas usando mais de um idioma! O sistema .NET é
inacreditavelmente flexível apenas por esse motivo; nunca foi desenvolvido um sistema que permita
integrar tantos paradigmas tão facilmente.

Just In Time Compilation – Compilação na hora certa

Todas as máquinas virtuais têm uma sobrecarga, como mencionei anteriormente. O sistema .NET
não é exatamente uma máquina virtual pura, no entanto. O sistema .NET faz algo realmente
inteligente: ele usa um método chamado compilação Just In Time (JIT) para acelerar a execução
do código. O sistema JIT monitora seu código MSIL e, sempre que você executa um módulo pela
primeira vez, ele pega seu código MSIL e o converte no código nativo de sua máquina. Portanto,
quando você executa um módulo .NET em sua máquina com Windows pela primeira vez, o JIT
carrega no código MSIL, o traduz diretamente em código x86 e, em seguida, salva esse código. A
partir desse, quando o módulo é executado, o computador executa o código x86 nativo e ignora
completamente qualquer uso da máquina virtual, então é quase como se você tivesse compilado
um programa diretamente de uma linguagem de alto nível para linguagem de máquina - mas não
é bem assim. A figura 1.3 mostra esse processo.

Figura 1.3 Seus módulos MSIL são convertidos em código nativo quando são primeiro executado,
evitando assim a penalidade de tradução toda vez que seu código é executado.

Teoria da Redução

A idéia por trás do .NET e das máquinas virtuais em geral é que programas em linguagens de alto
nível sempre podem ser “reduzidos” ou “reduzidos”. Tome, por exemplo, a ideia de imprimir
palavras no monitor. Em uma linguagem como C #, isso é feito por uma linha de código:

System.Console.WriteLine ("Eu gosto de tortas");

Mas o que isso faz realmente? Internamente, o computador basicamente apenas move alguma
memória e informa ao barramento de entrada/saída para enviar alguns dados para a tela. Em teoria,
qualquer comando complexo em qualquer idioma pode ser reduzido a um monte de comandos mais
simples.
Aqui está uma analogia do mundo real: quando você gira a chave de ignição em um carro, o carro
liga; isso é como uma linguagem de alto nível. Dentro do motor do carro, ocorre uma seqüência de
eventos:
1. A bateria começa a girar os pistões.
2. A bateria acende a vela de ignição.
3. A vela de ignição explode o gás nos cilindros.
4. O gás explosivo começa a girar os pistões ainda mais rápido.
Cada grande comando (como iniciar um motor de carro) pode ser dividido em um conjunto
específico de pequenos comandos (como os listados acima). Existem apenas alguns tipos
diferentes de comandos pequenos, e são nisso que as máquinas virtuais confiam. Você pode criar
uma linguagem super complexa que tenha funções como MakeSuperCoolGameNow (), mas no
final, o computador a reduz a uma sequência de comandos que fazem cálculos matemáticos e
movem a memória. Na verdade, isso é tudo que um computador faz - de qualquer maneira, faça
cálculos matemáticos e mova a memória.
Então, se tudo que uma máquina virtual precisa saber é como executar cálculos matemáticos e
mover a memória, isso significa que eles podem ser muito simples de fazer e fáceis de serem
portados para diferentes plataformas.

Nota__________________________________________________________________________
Existe toda uma área da ciência da computação dedicada à ideia de reduzir os problemas a uma
forma mais simples. Existe na verdade toda uma classe de problemas no computador, chamados
NP-Complete, onde cada problema pode ser reduzido a um problema que descreve todo problema
NPComplete no mundo._________________________________________________________________

O futuro
C # é o carro-chefe da Microsoft para a plataforma .NET. A empresa queria aceitar o C ++ e
consertar o que há de errado com ele; esse é um objetivo bastante robusto, mas se alguém tiver
recursos suficientes para resolver esse problema, é a Microsoft.
No momento em que escrevo, nenhum grande estúdio de jogos está desenvolvendo publicamente
com C #, mas isso é compreensível. A linguagem ainda está em sua infância, e uma grande
empresa não quer gastar milhões de dólares em um projeto que eles não têm 100% de certeza.
Com o tempo, no entanto, isso vai mudar. Na verdade, a maior vantagem sobre um sistema como
o .NET é a portabilidade que ele pode oferecer. Agora, se você quiser escrever um jogo para o PC
e um console de videogame, praticamente terá que escrever dois jogos, porque é provável que os
sistemas não tenham nada em comum. Esse é um tremendo problema para as empresas que estão
sem dinheiro e não podem se dar ao luxo de escrever dois jogos, então provavelmente terão que
se contentar em escrever o jogo para o PC ou para um console específico. No futuro, consoles
como o XBox 2 provavelmente suportarão o .NET, então deve ser possível escrever um jogo e
funcionar perfeitamente no PC e no console ao mesmo tempo! Assim como as linguagens de alto
nível introduziram um novo nível de semi-portabilidade para o mundo da informática, o .NET está
pronto para causar um impacto ainda maior.
Resumo
Este capítulo familiarizou você com as ideias por trás da plataforma .NET da Microsoft e lhe deu
uma idéia do que é a computação portátil. Embora tecnicamente você não precise aprender nada
disso, ainda sinto que é uma área muito importante deve estar familiarizado se você vai se
aprofundar na programação de jogos .NET.

O que você aprendeu

Os principais conceitos que você deve ter aprendido neste capítulo são:
As linguagens de máquina informam a um computador o que fazer.
As linguagens de montagem informam ao computador o que fazer em termos semelhantes aos
humanos.
Linguagens de programação de alto nível permitem que você abstraia seus programas
linguagem de máquina de baixo nível e permite que você os descreva de maneira mais fácil.
As máquinas virtuais traduzem o código de máquina imaginário em código de máquina real.
Máquinas virtuais podem ajudar a portar programas para muitas plataformas facilmente.
Todos os programas podem ser reduzidos em formatos de linguagem de máquina.
O .NET acelera o processo da VM traduzindo o código apenas na primeira vez em que é
executado.

Perguntas de revisão
Estas questões de revisão testam seu conhecimento dos conceitos importantes explicados neste
capítulo. As respostas podem ser encontradas no Apêndice A.
1.1. Por que uma máquina virtual diminui os programas?
1.2. Como a compilação JIT acelera a execução da VM?
1.3. Quais idiomas a Microsoft suporta oficialmente para o .NET?
1.4. Outras linguagens também podem suportar o .NET?

Por si só
Se você tem alguma linguagem de programação favorita, tente encontrar um projeto que compile
sua linguagem para o .NET. Por exemplo, pesquise na Internet por Ironpython se estiver
interessado na execução de programas em Python no .NET.

Capítulo 2
O básico

O Capítulo 1 mostrou um pouco do histórico do motivo pelo qual o .NET e o C # foram criados.
Agora é hora de mergulhar fundo no abismo e aprender como usar o C #. Neste capítulo, mostrarei
a você:
Como compilar e executar um programa c #.
O que é uma aula?
Que ponto de entrada é.
Os tipos de dados básicos.
Os operadores básicos matemáticos e bitwise.
Como declarar variáveis e constantes.
Como executar tipografias básicas.
Como criar ramificações de programa usando if e switch statements.
Como criar loops usando instruções while, for e do-while.
Como o escopo funciona.

Por que você deveria ler este capítulo

Se você já conhece uma linguagem como C / C ++ ou Java, então este capítulo será uma brisa
para você. De fato, você pode até ser tentado a pular este capítulo. Afinal, os fundamentos da
maioria das linguagens de programação são praticamente os mesmos dentro da família de
linguagens C. Infelizmente, embora as sintaxes de todas as linguagens sejam quase idênticas, o
comportamento de cada idioma é diferente. Na verdade, há muito sobre o C # que é diferente de
outros idiomas, por isso é de seu interesse ir em frente e ler este capítulo.

Seu primeiro programa C#

Há uma tradição antiga (bem, não é tão antiga) na programação de computadores que diz que seu
primeiro programa em qualquer idioma deve ser um programa “Hello World”, um programa que
simplesmente imprime uma mensagem de boas-vindas em seu computador. Você pode abri-lo em
qualquer editor de texto ou no Visual Studio e visualizá-lo.
O código deve ficar assim:
class HelloCSharp
{
static void Main( string[] args )
{
System.Console.WriteLine( “Hello, C#!!” );
}
}

À primeira vista, você pode ver que isso é cerca de quatro ou cinco linhas a mais do que você
poderia escrever em C ou C ++; é porque o C # é uma linguagem mais complicada.

Classes
C # é uma linguagem de programação orientada a objetos, o que pode não significar nada para
você neste momento. Eu examinarei os conceitos com muito mais detalhes no Capítulo 3, “Um
resumo Introdução às Classes ”, mas por enquanto, tudo que você precisa saber é que o C #
representa seus programas como objetos.
A ideia é separar seus programas em substantivos e verbos, onde cada substantivo pode ser
representado como um objeto. Por exemplo, se você fizer um jogo que tenha naves espaciais
voando por aí, você poderá pensar nas espaçonaves como objetos.
Uma classe em um programa C # descreve um substantivo; ele diz ao computador que tipo de
dados objetos terão e que tipo de ações podem ser feitas neles. Uma classe de naves espaciais
pode dizer ao computador sobre quantas pessoas estão nele, quanto de combustível resta e com
que velocidade está indo.
Em C #, todo o seu programa é na verdade uma aula. No Demo 2.1, você tem a classe HelloCSharp,
que é o nome do programa.

O ponto de entrada
Cada programa tem um ponto de entrada, o lugar no código onde o computador irá iniciar a
execução. Em linguagens mais antigas, como C e C ++, o ponto de entrada era tipicamente uma
função global chamado main, mas em c # é um pouco diferente. O C # não permite que você tenha
funções globais, mas, ao invés disso, obriga a colocar suas funções em classes, portanto,
obviamente, você não pode usar o mesmo método para um ponto de entrada do C #. C # é como
Java nesse aspecto; o ponto de entrada para cada programa C # é uma função estática chamada
Main dentro de uma classe, como a que você viu definida na Demo 2-1. Eu cobrirei funções e
funções estáticas com muito mais detalhes no Capítulo 3, portanto, tenha paciência comigo por
enquanto.

Todo programa C # deve ter uma classe que tenha uma função Main estática; se isso não
acontecer, o computador não saberá por onde começar a executar o programa. Além disso, você
só pode ter uma função principal definida em seu programa; Se você tiver mais de um, o
computador não saberá com qual começar.

Nota__________________________________________________________________________
Tecnicamente, você pode ter mais de uma função principal em seu programa, mas isso deixa as
coisas bagunçadas. Se você incluir mais de um Main, precisará informar ao seu compilador C # qual
classe contém o ponto de entrada - isso é realmente um monte de problemas que você pode viver
sem.__________________________________________________________________________

Olá, c # !!

A parte do programa que realiza a impressão é esta linha:

System.Console.WriteLine (“Olá, C # !!”); Essa linha obtém a classe System.Console - que é
incorporada na estrutura .NET - e informa para imprimir “Hello, C # !!” usando sua função WriteLine.

Compilando e executando
Existem algumas maneiras de compilar este programa e executá-lo. A maneira mais fácil seria abrir
uma janela de console, encontrar o caminho para o diretório de demonstração e usar o compilador
C # de linha de comando para compilar o arquivo, desta forma:

csc HelloCSharp.cs

A outra maneira de compilar este programa seria carregar o arquivo do projeto 01-
HelloCSharp.cmbx no SharpDevelop ou o arquivo 01-HelloCSharp.sln no Visual Studio.NET,
dependendo de qual IDE você está usando. Você pode encontrar instruções mais detalhadas sobre
como fazer isso no Apêndice B.

Agora, quando você executa o programa, você deve obter uma saída simples na tela:

Olá, c # !!

Ta-da! Agora você tem seu primeiro programa em C #, que mostra algum texto na sua tela!

O básico
Quase toda linguagem de programação tem propriedades comuns. Por um lado, as linguagens de
programação geralmente sabem como armazenar dados. Eles também devem operar com esses
dados movendo-os e realizando cálculos sobre eles.

Tipos Básicos de Dados

Como a maioria das linguagens de programação, o C # possui um grande número de tipos de dados
internos, representando principalmente números de vários formatos. Estes são mostrados na
Tabela 2.1.

Nota__________________________________________________________________________
C # é uma linguagem extensível, o que significa que você pode criar seus próprios tipos de dados
mais tarde, se desejar. Eu vou entrar em mais detalhes sobre isso no Capítulo 3.______________

Table 2.1 C# Built-in Data types

Type Size (bytes) Values

bool 1 true or false

byte 1 0 to 255

sbyte 1 -128 to 127

 char 2 Alphanumeric characters (in Unicode)

short 2 -32,768 to 32,767

ushort 2 0 to 65,535

int 4 -2,147,483,648 to 2,147,483,647

uint 4 0 to 4,294,967,295

*float 4 -3.402823x1038 to 3.402823x1038

long 8 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

ulong 8 0 to 18,446,744,073,709,551,615

*double 8 -1.79769313486232x10308 to 1.79769313486232x10308

**decimal 16 -79,228,162,514,264,337,593,543,950,335 to
79,228,162,514,264,337,593,543,950,335

* - These are floating-point formats, which can represent inexact decimal values
* - This is a fixed-point format, which represents exact decimal values with up to 28 digits

Os tipos baseados em inteiro (byte, short, int, long e assim por diante) podem armazenar apenas
números inteiros, como 0, 1, 2 e assim por diante; eles não podem conter números decimais, como
1,5 ou 3,14159.
Para manter os números decimais, você precisa alternar para um formato de ponto flutuante ou um
formato de ponto fixo. Os detalhes exatos de como esses números são armazenados estão além
do escopo deste livro, mas há uma diferença sutil que afeta cientistas e matemáticos (mas
provavelmente não programadores de jogos).

Nota__________________________________________________________________________
Basicamente, os números de ponto flutuante não podem conter números precisos; eles só podem
se aproximar de números decimais dentro de uma certa quantidade de erro. Por exemplo, usando
floats, você pode representar os números 1.0 e 1.00000012, mas não pode representar nenhum
número entre eles. Portanto, se você definir um float como igual a 1.00000007, o computador
arredondará automaticamente para 1.00000012. Os duplos são da mesma maneira, mas têm mais
precisão (até 15 dígitos). Os decimais são codificados de maneira diferente e, embora a
documentação do .NET os chame de números de ponto fixo, eles ainda são tecnicamente números
de ponto flutuante e têm uma precisão de até 28 dígitos._____________________________________

Operadores
Operadores são símbolos que aparecem em uma linguagem de computador; eles dizem ao
computador para realizar certos cálculos nos dados. Os operadores costumam ser usados em
equações matemáticas, por isso, tenho certeza de que esse conceito será muito familiar para você.
A linguagem C # tem vários operadores integrados na linguagem e, se você já usou C ++ ou Java,
provavelmente já conhece a maioria deles.

Operadores matemáticos
C # tem cinco operações matemáticas básicas construídas na linguagem, conforme mostrado na
Tabela 2.2.

Table 2.2 Basic Mathematical Operators in C#

Operator Symbol Example Result

Addition + 5+6 11

Subtraction - 6-5 1

Multiplication * 6*7 42

Division / 8/4 2

Modulus % 9%3 0

Increment ++ 10++ 11

Decrement — 10— 9

Os primeiros quatro operadores são não-brainers (algo que requer ou envolve pouco ou nenhum
esforço mental), ou pelo menos deveriam ser. O quinto operador pode ser novo para você, se você
não tiver feito muita programação antes. Módulo é por vezes conhecido como “o operador restante”
ou “o operador do relógio”. Basicamente, o resultado de uma operação do módulo é a mesma do
restante, se você pegar o primeiro número e dividi-lo pelo segundo. No exemplo dado na Tabela
2.2, 3 divide em 9 uniformemente, então o restante é 0. Se você tomou 10% 3, o resultado seria 1,
pois o restante de 10/3 é 1.

Nota__________________________________________________________________________
O módulo é frequentemente chamado de operador do relógio porque você pode calcular facilmente
o resultado usando um relógio. Por exemplo, pegue o cálculo de 13% 12. Imagine que você tem a
mão de um relógio a partir de 12, e você avança uma hora a cada vez que você conta por 1. Então,
quando você contar até 1, a mão estará em 1 e quando você contar até 2, a mão estará em 2 e assim
por diante. Eventualmente, quando você chegar a 12, a mão estará em 12 novamente, e quando você
contar até 13, a mão volta para 1. Então o resultado de 13% 12 é 1.

______________________________________________________________________________
Nota__________________________________________________________________________
Os operadores de incremento e decremento, na verdade, possuem duas versões diferentes: as pós
e pré-versões. Por exemplo, ++ x é a versão pré-incremento e x ++ é a versão pós-incremento. A
diferença é quando os operadores realmente realizam seus cálculos. Por exemplo, se x for 10 e você
escrever y = x ++, o computador primeiro coloca o valor de x em y e, em seguida, incrementa x,
deixando y igual a 10 e x igual a 11 quando o código é feito. Por outro lado, y = ++ x executa o
Incremento primeiro e realize a tarefa mais tarde, deixando x e y igual a 11. Esse é outro resquício de
C e pode torná-lo feio e difícil de ler, por isso não recomendo muito usar esses operadores.
______________________________________________________________________________

Você deve notar que todos os operadores matemáticos têm versões alternativas que permitem que
vocè modifique diretamente uma variável (veja mais sobre as variáveis mais adiante neste capítulo).
Por exemplo, se você quiser adicionar 10 a x, poderá fazer isso:

x = x + 10;

Mas isso é um pouco desajeitado e redundante. Em vez disso, você pode escrever isto:

x + = 10;

Todos os outros operadores matemáticos têm versões semelhantes:

x * = 10; // multiplique por 10

x / = 10; // dividir por 10
x - = 10; // subtrair 10
x% = 10; // módulo por 10
x >> = 2; // deslocar para baixo por 2
x << = 2; // deslocar por 2

Operadores de matemática bit a bit – Bitwise

Além dos operadores matemáticos padrão, há também operadores matemáticos bit-a-bit, que
executam operações matemáticas binárias em números. Os operadores bitwise básicos em C #
estão listados na Tabela 2.3.
 Table 2.3 Basic Bitwise Operators in C#

Operator Symbol Example Result

Binary And
& 6 & 10 2

Binary Or
| 6 | 10 14

Binary Xor
^ 6 ^ 10 12

Binary Not ~ ~7* 248

* - this example is performed on a byte

Os operadores matemáticos bit a bit também têm versões alternativas:

x & = 10; // e por 10
x | = 10; // ou por 10
x ^ = 10; // xor por 10
Operadores de deslocamento

Existem dois operadores de mudança, << e >>. Esses operadores deslocam os bits em um número
para cima ou para baixo, resultando nas seguintes equações:

- x << y é o mesmo que x * 2y

- x >> y é o mesmo que x / 2y

Então, 5 << 3 é o mesmo que 5 * 8, ou 40, e 40 >> 3 é o mesmo que 40/8, ou 5.

Nota__________________________________________________________________________
O Bitshifting é muito mais rápido que a multiplicação ou divisão direta, mas agora raramente é usado.
A economia de velocidade não é tão espetacular e dificulta a leitura de seus programas.

______________________________________________________________________________

Operadores lógicos

Existem alguns operadores lógicos comuns que realizam comparações em coisas e retorne os
valores booleanos como true ou false, dependendo do resultado. A Tabela 2.4 lista os operadores
lógicos.

Table 2.4 Logical Operators in C#

Operator Symbol Example Result

Equals == 1 == 2 false

Des Not Equal != 1 != 2 true

Less Than < 1<2 true

Greater Than > 1>2 false

Less Than or Equal To <= 1 <= 2 true

Greater Than or Equal To >= 1 >= 2 false

Logical And && true && false false

Logical Or || true || false true

Logical Not ! !true false

PÁGINA 41 DO ORIGINAL