Benjamin Breeg

Seu código esta funcionando corretamente, o windows.h é necessário porque ele que passa a estrutura do arquivo BMP pro render. https://msdn.microsoft.com/pt-br/library/windows/desktop/dd183392(v=vs.85).aspx Não use Glut, ele é muito antigo e desatualizado, seu uso é desencorajado ate pelos desenvolvedores do OpenGL: https://www.khronos.org/opengl/wiki/Related_toolkits_and_APIs Testei com o pacote compilado do site transmissionzero e esta ok. https://www.transmissionzero.co.uk/software/freeglut-devel/ O que pode estar acontecendo ai se você usa CodeBlocks, é que ele não encontra o arquivo.bmp se você tentar executar diretamente pelo build and run, você tem que colocar a imagem no diretório do projeto mais especificamente \nomeprojeto\bin\debug e executar o arquivo a partir dessa pasta.

Se for sistema Windows um jeito simples de fazer isso no C é usar a estrutura SYSTEMTIME presente no windows.h https://msdn.microsoft.com/pt-br/library/windows/desktop/ms724950(v=vs.85).aspx Isso que você quer fazer fica +/- assim: #include <windows.h> #include <stdio.h> int main() { SYSTEMTIME str_t; GetSystemTime(&str_t); int anoAtual = str_t.wYear; printf("%d\n",anoAtual); return 0; }

Acho que para fazer isso de forma mais eficiente ou não, o ideal mesmo seria aprender as funções da WinAPI para controlar diretamente os serviços de impressão do Windows. Tentei fazer algo aqui usando ShellExecute, ate funciona mas ele abre a janelinha de configuração da impressora antes de imprimir, deve ter como tirar isso mas só estudando mesmo a parte da WinAPI que controla a impressão. https://msdn.microsoft.com/en-us/library/ff686799(v=vs.85).aspx #include <windows.h> int main() { LPCTSTR teste = "teste.html"; ShellExecute(NULL, "print", teste, NULL, NULL, SW_SHOWNORMAL); system("PAUSE"); }

Cara aqui eu testei usando Windows 7 e deu certo. Da uma olhada nisso: http://www.ehow.com.br/opções-linha-comando-bloco-notas-lista_7089/ O programinha que usei para teste é esse: #include <iostream> #include <fstream> using namespace std; int main() { ofstream file; file.open("impressao.txt"); file<<"usando a impressora no C++"; file.close(); system("notepad /p impressao.txt"); }

O c++ não tem suporte nativo a impressoras, o que você poderia fazer é usar a função system do C++ para executar um programa que imprima um arquivo de texto via linha de comando por Ex: Notepad. Depois do texto criado pelo c++, imprimir usando o comando system("notepad /p arquivo txt") dentro do próprio programa c++.

Acho que se você quer começar bem no C, o primeiro livro que deveria ler é o clássico: "C Programming Language" vulgo "K&R C" É um livro pequeno de quase 300 paginas escrito pelo criador da linguagem Dennis Ritchie em parceria com o Brian Kernighan, ou seja praticamente tudo que você precisa saber e mais um monte de códigos muito bem explicados. Se procurar você acha uma versão traduzida em algum sebo ou se possuir um nível de inglês básico para leitura pode comprar a 2 edição na internet.

Não sei se entendi direito mas acho que você quer fazer um sistema de inventario para um jogo, isso é um tanto complexo para apenas 2 meses de estudos na linguagem C++, é possível fazer com arrays que é a mais básica das estruturas de dados e depois ainda teria que aprender alguma API gráfica tipo SDL, Allegro, SFML para codificar a parte gráfica do inventario para guardar itens, armas etc etc.

O struct do C++ tecnicamente é parecido com o class, acho que a única diferença são os modificadores de acesso que no struct é sempre publico, o struct do C++ tambem permite que você tenha funções membros dentro da estrutura, no C acho que é aceito apenas os tipos. Veja se isso te ajuda: http://www.cprogressivo.net/2013/03/Como-enviar-uma-struct-para-uma-funcao-em-C.html

Como bem disse o TYSQUARE89 no outro tópico é um jogo que vai exigir varias técnicas de programação e conhecimentos específicos mas veja se isso te ajuda a dar um pontapé inicial. Ele da uma ideia de como os socket funcionam, ai depois de entender bem essa parte, você pode tentar iniciar a programação do jogo propriamente dita, eu recomendaria ler um bom livro de programação C++ para redes. Um bom livro que é bem aclamado é o C++ Network Programming Volume I e II.

Você teria que estudar as funções para gráficos primitivos do Allegro para desenhar pontos, linhas, curvas a partir de cálculos matemáticos. http://liballeg.org/stabledocs/en/alleg013.html Não estudei nada a respeito mas aqui tem um exemplo das curvas de Bezier em Allegro 4, essas curvas são exemplo de gráfico vetorial usado por muitos programas gráficos. Acho que pode te ajudar a começar algo. //================================================================ // Nome do Arquivo: random_arcs.c // Filename: random_arcs.c // // Descrição: O programa exibe curvas de bezier em posições e // cores aleatórias usando a função arc da biblioteca allegro //================================================================ #include <cstdlib> #include <ctime> #include <allegro.h> int main(int argc, char *argv[]) { // Coordenadas dos 4 pontos de controle da curva int points[8]; // Cor da curva int color; // Contador int i; // Inicializa a biblioteca Allegro allegro_init(); // Inicializa o módulo do relógio install_timer(); // Inicializa o teclado install_keyboard(); // Define a profundidade de cores para 32 bits set_color_depth(32); // Define a resolução de 640x480 no modo janela set_gfx_mode(GFX_AUTODETECT_WINDOWED,640, 480, 0, 0); // Muda o título da janela set_window_title("Curvas de Bezier"); // Inicia o gerador de números aleatórios srand(time(NULL)); // Fica em loop até pressionar a tecla ESC while(!key[KEY_ESC]) { // Configura os atributos da curva for(i = 0; i < 4; i++) { points[i*2] = rand() % 640; points[i*2 + 1] = rand() % 480; } color = makecol(rand() % 256, rand() % 256, rand() % 256); // Desenha uma curva de bezier em posição e cor aleatória spline(screen, points, color); // Espera 300 milisegundos para economizar processamento rest(300); // Espera a sincronização vertical vsync(); } // Sai do programa allegro_exit(); return 0; } // Esta macro converte o main para WinMain() END_OF_MAIN(); Exemplo retirado do site: http://www.programasprontos.com/tag/computacao-grafica/

Você tem que se ligar na ordem de precedência dos operadores e o sentido da execução das expressões, estude bem isso. http://en.cppreference.com/w/c/language/operator_precedence Como diria Bjarne Stroustrup (criador do C++) quando houver duvidas use os parênteses. Seguindo a ordem: (a += (b % (c++)));

Para ambiente Windows não tem muito pra onde correr, Vs 2017 e Code::Blocks são excelentes, você pode tentar o NetBeans com suporte a C++, nunca testei mas tem uma galera que gosta. Agora se nenhuma IDE te satisfaz resta usar algum editor de código tipo NotePad++ ou Sublime Text e compilar os programas pela linha de comando.

Tente instalar a ultima versão do CodeBlocks do site oficial, provavelmente esse instalador do livro já deve estar desatualizado e isso pode estar causando alguma incompatibilidade com os sistemas de segurança presentes no Windows: Anti vírus, UAC etc etc. http://www.codeblocks.org/downloads/26 Baixe a versão "codeblocks-16.01mingw-setup.exe" Porque como você alega que o programa esta compilando, se não esta gerando o executável ou se gera e apaga logo depois pode ser seu Anti vírus ou outro sistema de segurança deletando o executável.

Na verdade você so define a posicao do canto superior esquerdo. se são por ex.. 2 sprites na horizontal e 4 na vertical #define baixo 0 #define esquerda 20 #define direita 40 #define cima 60 Esse espaço da animação você define na própria função masked_blit como no exemplo do mario multiplicando x pela largura e y pela altura a cada iteração do loop ou na função de controle como no exemplo daquele personagem de rpg if (!key[KEY_RIGHT] && !key[KEY_LEFT] && !key[KEY_UP] && !key[KEY_DOWN]){ spriteX = 20; } else { spriteX += 20; } if (spriteX > 40){ // limite do sprite spriteX = 0; } heroi_varios.zip Eu lembrei que tinha as animações desse personagem naquele jogo da princesa, veja se você consegue fazer uma folha com aquela mesma disposição, preciso aprender como aprender os sprites separados porque não é obrigatório estar na folha.

Sim e também é interessante frisar que a disposição dos sprites na folha segue o mesmo sentido. BAIXO ESQUERDA DIREITA CIMA na sequencia pelas colunas. Eu estou vendo uma forma melhor de fazer isso, algo que seja mais eficiente e não muito confuso, na pratica tem muitas formas de fazer.

Essas definições nao tem relação com a colisão, elas são responsáveis pelas coordenadas para definir a orientação do boneco dentro da folha de sprites, se você reparar nessa folha de sprites pode ver que numa faixa o boneco esta olhando para frente (baixo), esquerda, direita e de costas (cima) portanto quando você aperta seta pra baixo (boneco de frente) ele vai para a coordenada 0 do canto superior esquerdo da folha que corresponde a animação do boneco andando pra baixo, se selecionar seta para cima ele vai para a coordenada 96 que corresponde a animação do boneco andando pra cima e por ai vai. Se você mudar a folha vai ter que mudar os valores, o ideal é pegar folhas que dividindo a largura pela quantidade de sprites na horizontal e a altura pela quantidade de sprites na vertical de valores iguais, isso facilita muito na hora de trabalhar com sprites animados. Ex. 288 / 3 e 384 / 4 = sprites de 96x96.

Então o problema é que para esse tipo de colisão precisa que o sprites sejam da mesma dimensão, para não ter que usar sprites pequenos pra fazer labirintos grandes a solução seria usar a camera, um recurso que você pode rolar a tela e assim poder usar mapas realmente grandes. Esse fim de semana eu vou ter um tempo de mexer ai tento implementar a camera para ver como fica, uma solução é tentar achar folhas de sprites com sprites 20x20.

Bom nunca tentei fazer nada de criptografia e nem entendo de C# mas pelo que entendi esse algoritmo de Cesar é um algoritmo que troca as letras do alfabeto, na teoria ele usaria apenas 52 caracteres que corresponde a 26 letras do alfabeto em minúsculo e 26 letras do alfabeto em maiúsculo o que poderia ser feito tranquilamente usando a codificação UTF8 que é compatível com a tabela ascii padrão. O tipo char pode representar apenas os 256 números ou 256 caracteres codificados da tabela ascii ocupando 1 byte de memória ( 1 byte = 8 bits). porém na pratica o tipo char não consegue representar todos os caracteres existentes atualmente, esse teu algoritmo deve usar muito mais caracteres que os suportados pela tabela ascii padrão mas como eu disse não conheço o C#, teria que ver se a Microsoft segue o padrão da tabela ascii para o tipo char. UTF-32 ocupa 4 bytes ( 4 bytes = 32 bits) e com essa quantidade de bytes é possível representar mais de 4 bilhões de valores diferentes. Porque uma codificação tão grande num algoritmo que em tese é simples não sei te explicar.

Sim por padrão o tamanho é uma potencia de 2 mas não saberia te dizer porque os computadores trabalham dessa forma. Ex. 2 elevado a quinta = 32 2 elevado a sexta = 64 2 elevado a setima = 128 e por ai vai... Atualmente as API graficas estão mais relaxadas quanto a esse padrão, porém você sabendo o tamanho certo de cada sprite facilita muito, o ideal é pegar as folhas de sprites com imagens 32x32, 64x64 etc etc. Essa do Mario teria que trabalhar ela pra ficar certinha e ai pegar as medias como o cara fez no vídeo. Tente isso. #include <allegro.h> #define baixo 0 #define esquerda 32 #define direita 64 #define cima 96 int x = 0; int y = 400; int spriteX = 32; int spriteY = baixo; int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0); BITMAP* buffer = create_bitmap(800, 600); BITMAP* heroi = load_bitmap("heroi.bmp", NULL); while(!key[KEY_ESC]) { if (key[KEY_RIGHT]){ spriteY = direita; x += 5; } else if (key[KEY_LEFT]){ spriteY = esquerda; x -= 5; } else if (key[KEY_UP]){ spriteY = cima; y -= 5; } else if (key[KEY_DOWN]){ spriteY = baixo; y += 5; } if (!key[KEY_RIGHT] && !key[KEY_LEFT] && !key[KEY_UP] && !key[KEY_DOWN]){ spriteX = 32; } else { spriteX += 32; } if (spriteX > 64){ // limite do sprite spriteX = 0; } masked_blit(heroi, buffer, spriteX, spriteY, x, y, 32, 32); draw_sprite(screen, buffer, 0, 0); rest(80); clear(buffer); } destroy_bitmap(buffer); destroy_bitmap(heroi); return 0; } END_OF_MAIN() Folha de Sprite. heroi.zip Seguindo o exemplo do Mario que ele fez, editei um bitmap com as mesmas características ou quase... A imagem tem 593x314, se os sprites estiverem distribuídos corretamente é so fazer uma continha basica: São 6 sprites na horizontal portanto 593 / 6 que eu arredondei para 100 ja que tem uma sobra ali e 2 sprites na vertical portando 314 / 2 = 157. Então cada sprite na folha ficou tem 100x157 Agora fica fácil colocar os dados ali no programa, usei o exemplo dele sem a parte do cenário, também coloquei alguns comentários. #include <allegro.h> void control(); // x e y é onde o frame esta localizado no buffer (posicao da imagem na tela) // wx e wy são as coordenadas do canto superior esquerdo do sprite // w e h é a largura e altura de cada frame // 0 é o canto superior esquerdo da fileira de sprites de cima // 157 é o canto superior esquerdo da fileira de sprites de baixo // wx faz a animacao do mario andar pra direita // wy faz a animacao do mario andar pra esquerda struct obj {int x, y, wx, wy, w, h;}; struct obj p {300, 370, 0, 157, 100, 157}; int nTile = 0, dir = 0, i; int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0); BITMAP* buffer = create_bitmap(800, 600); BITMAP* mario = load_bitmap("mario.bmp", NULL); while(!key[KEY_ESC]) { control(); masked_blit(mario, buffer, p.wx + nTile*100, p.wy - dir*157, p.x, p.y, p.w,p.h); draw_sprite(screen, buffer, 0, 0); rest(80); clear(buffer); } destroy_bitmap(buffer); destroy_bitmap(mario); return 0; } END_OF_MAIN() void control() { if (key[KEY_LEFT]) { p.x -= 20; dir = 0; nTile--; } else if (key[KEY_RIGHT]) { p.x += 20; dir = 1; nTile++; } else { nTile = 5; } if (nTile < 0) { // sprite 0,1,2... e repete o ciclo nTile = 2; } if (nTile > 2 && nTile != 5) { //seleciona sprite n 5 quando personagem esta parado nTile = 0; } } Folha de sprite: mario.zip

Funciona porque se não me engano o c++ tem 2 modos de usar a função getline, o da classe string onde a função é sobrecarregada para manipular os objetos e outro modo que funciona como o char primitivo do C. string v1; getline(cin, v1); Seria o equivalente no C char v1[50]; scanf("%s",v1);

Falha minha para C coloque: #include <stdbool.h>

Da uma estudada no tutorial de pacman do deividcoptero, ele usou Allegro mas não ser muito difícil converter para console depois que você entender a lógica por trás do jogo. Por exemplo a função que desenha o mapa você pode usar tabela ascii para fazer as paredes etc etc. #include <stdio.h> #define LINHA 20 #define COLUNA 31 void desenha_mapa(); int mapa[LINHA][COLUNA] = { {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}, {1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1}, {1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1}, {1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1}, {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, {1,0,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,0,1}, {1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1}, {1,0,1,1,1,0,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,0,1,1,1,0,1}, {1,0,1,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,0,1}, {1,0,0,0,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,0,0,0,0,1}, {1,0,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,0,1}, {1,0,1,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,0,1}, {1,0,1,1,1,0,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,0,1,1,1,0,1}, {1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1}, {1,0,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,0,1}, {1,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1}, {1,0,1,1,1,0,1,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,0,1}, {1,0,1,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,1,0,1}, {1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1}, {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} }; int main() { desenha_mapa(); return 0; } void desenha_mapa() { int l,c; for(l=0;l<LINHA;l++) { for(c=0;c<COLUNA;c++) { switch(mapa[l][c]) { case 0: printf(" "); break; case 1: printf("%c", 219); break; } } printf("\n"); } }

Acho que não funciona chamando uma função do C++, tem que usar as próprias callback do Allegro para fechar no X. Algo mais ou menos assim: #include <allegro.h> volatile int saiu = false; void fechar() { saiu = true; } END_OF_FUNCTION(fechar) int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0); set_window_title("Teste"); LOCK_FUNCTION(fechar); set_close_button_callback(fechar); while (!saiu) {} } END_OF_MAIN();

Ao invés de usar Sleep() com o winalleg.h (windows.h do allegro), usa a função rest() do allegro, ai fica independente da plataforma (Linux/Windows) Lembrando que se usar o windows.h direto da problema de conflito entre o Allegro e a Windows API, elas usam a mesma estrutura de nomes em muitas funções.

Legal você ter feito as modificacoes na versão do TYSQUARE89 para rodar no Windows, tem que ver com ele se la esta colidindo com todo os blocos, aqui apenas colidiu com um bloco. A vantagem desse método ai eh que a colisão funciona para todos os elementos do array. A noite eu vejo esse problema que você relatou mas acho que tem que usar um sistema de telas como os caras usaram no vídeo, so que eles usaram tipo cada mapa é uma função e nessa função faz todo a configuração de tela, desenho tudo novamente. Existem formas melhores de fazer isso. Mas uma dica que dou e que não tente copiar e colar, leia cada linha, tente entender o que foi feito e implemente no seu código sempre fazendo alguma melhoria. Se entrar nessa de copy and paste o código pode funcionar mas vira uma bomba relógio.