Benjamin Breeg

28 de abril de 2023

Você já viu a serie de vídeos sobre Engine de Raycasting do canal manual do código? É um dos materiais mais completos no youtube sobre raycasting. São mais de 40 vídeos onde ele explica passo a passo como implementar inclusive toda a parte matemática.

22 de fevereiro de 2023

Bit blitting é obsoleto com o hardware que temos hoje em dia. A maneira mais eficiente ate mesmo para simples jogos 2D é criar geometria de triângulos, fazer o mapeamento das texturas e enviar diretamente para a placa de vídeo. Vale lembrar que placas de vídeo são projetadas para manipular quantidades absurdas de polígonos portanto enviar diretamente os bitmaps para a memória é desperdiçar processamento.

A SFML por exemplo tem ferramentas para criar essa geometria de triângulos.

https://www.sfml-dev.org/tutorials/2.5/graphics-vertex-array.php

Pode ser uma boa começar por ai.

9 de setembro de 2021

Acho que com o hardware que temos disponível hoje em dia a maneira mais eficiente de desenhar coisas ate mesmo 2D é construir formas com triângulos, fazer o mapeamento de texturas e enviar para a placa de vídeo já que a engenharia das GPU desde a mais simples ate as mais poderosas é basicamente gerar uma quantidade absurda de triângulos numa velocidade altíssima, não tem porque não usarmos essas capacidades.

Na SFML e acredito que outras bibliotecas você pode criar geometria de triângulos de forma mais simples, aqui nesse link tem um tutorial sobre os vertex arrays, que é uma uma maneira mais baixo nível de manipular triângulos sem que ter programar diretamente em OpenGL, DirectX ou ter que estudar aqueles livros de geometria que quebra o seu pé se cair. Aqui tem o exemplo de como criar um tilemap que é base pra muitos jogos.

https://www.sfml-dev.org/tutorials/2.5/graphics-vertex-array.php

11 de abril de 2021

Essa é a tradução da primeira versão do livro que cobre o C++98, a mais atual (2 edição) já é revisada para as versões C++ 11 e C++14. Não achei nenhuma informação de uma terceira edição revisada pra versões mais modernas do C++.

6 de abril de 2021

Você não esta tentando usar o source do allegro5 sem compilar para gerar as dll etc etc ?

Verifique o arquivo que baixou para ver se não é isso, tenha certeza que baixou os binários para Windows para MinGW ou compilador Microsoft ou os arquivos para Linux.

https://github.com/liballeg/allegro5/releases

16 de março de 2021

O grande problema é que a versão 4 só aceita resoluções pré-definidas, não digo que você não consiga fazer funcionar mesclando win32 ou outras peripécias técnicas mas vai ser uma gambiarra daquelas.

Eu vi aqui que em 2019 lançaram uma versão nova do Allegro 4.. a versão 4.4.3, pelo que diz o post do dev fizeram muitos bugfixes e parece que mexeram em coisas relacionadas a problemas no modo full screen. Se você não quer de jeito nenhum migrar para a versão 5 pode ser um bom ponto de partida dar uma olhada.

https://www.allegro.cc/forums/thread/617731

http://members.allegro.cc/EdgarReynaldo/BuildA4.html

testei aqui o o MinGW i686-8.1.0-release-posix-dwarf-rt_v6-rev0 e funcionou perfeitamente.

12 de março de 2021

Você esta dizendo criar a janela Win32 e fazer o Allegro usar esse contexto Win32? Em APIs como a SFML você consegue criar um contexto Win32 e usar funções da SFML livremente, o Allegro não da suporte a esse recurso nem na versão 5 creio eu. Poderia ser possível ne, na pratica o Allegro usa a Win32 por trás da cortina.

10 de março de 2021

13 minutos atrás, Daniel Bittencourt disse:

eu uso allegro 4.2.2 ;-;

Cara acho que o Allegro 4 não suporta resoluções definidas pelo usuário que seria o caso, você pode ter fullscreen e windowed mas não tenho certeza se realmente não aceita fullscreen window. So vendo mesmo.

10 de março de 2021

No Allegro 5 você pode usar o "ALLEGRO_FULLSCREEN_WINDOW" para setar uma janela em tela cheia com a barra visível

Aqui um exemplo aperta "M" para você ver o efeito, veja se é o que você quer.








#include "allegro5/allegro.h"
#include "allegro5/allegro_font.h"
#include "allegro5/allegro_ttf.h"

#include "allegro5/allegro_direct3d.h"


#include <cstdio>



class Display {
protected:
   ALLEGRO_DISPLAY* display;
   ALLEGRO_EVENT_QUEUE* queue;
   ALLEGRO_TIMER* timer;
   ALLEGRO_FONT* verdana20;
   int origw;
   int origh;
   int w;
   int h;
   int xpos;
   int ypos;
   int adapter;
   bool opengl;
   bool redraw;
   bool quit;
   bool fullscreen;

   
   
public :
   
   Display();
   
   int Init();
   
   bool Create(int width , int height , int adapter , bool use_opengl);
   void Destroy();
   void RefreshInfo();
   void DisplayInfo();
   void Register();

   void ToggleFullscreen();
   
   bool SetAdapter(int nadapter);
   bool UseOpenGL();
   bool UseDirect3D();

   void CheckInput();
   
   void Draw();
   
   void Run();
   
   bool Quit() {return quit;}
};



int main(int argc , char** argv) {
   
   
   
   Display d;
   int ret = d.Init();
   if (ret != 0) {return ret;}
   
   if (!d.Create(800 , 600 , 0 , true)) {
      return 1;
   }
   
   d.Run();
   
   
   
   return 0;
}



Display::Display() :
   display(0),
   queue(0),
   timer(0),
   verdana20(0),
   origw(0),
   origh(0),
   w(0),
   h(0),
   xpos(0),
   ypos(0),
   adapter(0),
   opengl(true),
   redraw(true),
   quit(false),
   fullscreen(false)
{}



int Display::Init() {
   
   if (!al_init()) {
      return -1;
   }
   if (!al_init_font_addon() || !al_init_ttf_addon()) {
      return -2;
   }
   
   if (!al_install_keyboard()) {
      return -3;
   }
   if (!al_install_mouse()) {
      return -4;
   }
   
   queue = al_create_event_queue();
   if (!queue) {
      return -6;
   }

   timer = al_create_timer(1.0/60.0);
   if (!timer) {
      return -7;
   }   

   al_register_event_source(queue , al_get_keyboard_event_source());
   al_register_event_source(queue , al_get_timer_event_source(timer));
   al_register_event_source(queue , al_get_mouse_event_source());
   
   
   verdana20 = al_load_ttf_font("Verdana.ttf" , -20 , 0);
   if (!verdana20) {
      return -10;
   }
   
   return 0;
}



bool Display::Create(int width , int height , int new_adapter , bool use_opengl) {
   Destroy();
   int ndflags = ALLEGRO_WINDOWED | ALLEGRO_RESIZABLE | (use_opengl?ALLEGRO_OPENGL:ALLEGRO_DIRECT3D);
   al_set_new_display_flags(ndflags);
   al_set_new_display_adapter(new_adapter);
   origw = width;
   origh = height;
   display = al_create_display(origw,origh);
   if (display) {
      opengl = use_opengl;
      adapter = new_adapter;
      Register();
      al_start_timer(timer);
   }
   redraw = true;
   return display;
}



void Display::Destroy() {
   if (display) {
      al_stop_timer(timer);
      al_destroy_display(display);
      display = 0;
   }
}



void Display::RefreshInfo() {
   al_get_window_position(display , &xpos , &ypos);
   w = al_get_display_width(display);
   h = al_get_display_height(display);
}



void Display::DisplayInfo() {
   RefreshInfo();
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 10 , 0 , "Window position <%d , %d>" , xpos , ypos);
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 40 , 0 , "Window dimensions <%d , %d>" , w , h);
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 70 , 0 , "Adapter #%d" , adapter);
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 100 , 0 , "%d Available adapters" , al_get_num_video_adapters());
   al_draw_textf(verdana20 , al_map_rgb(255,255,255) , 10 , 130 , 0 , "Using %s" , opengl?"OpenGL":"Direct3D");
}



void Display::Register() {
   al_register_event_source(queue , al_get_display_event_source(display));
}



void Display::ToggleFullscreen() {
   fullscreen = !fullscreen;
   al_set_display_flag(display , ALLEGRO_FULLSCREEN_WINDOW , fullscreen);
}



bool Display::SetAdapter(int nadapter) {
   return Create(w , h , nadapter , opengl);
}

bool Display::UseOpenGL() {
   return Create(w , h , adapter , true);
}
bool Display::UseDirect3D() {
   return Create(w , h , adapter , false);
}



void Display::CheckInput() {
   do {
      ALLEGRO_EVENT ev;
      al_wait_for_event(queue , &ev);
      if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE || (ev.type == ALLEGRO_EVENT_KEY_DOWN && ev.keyboard.keycode == ALLEGRO_KEY_ESCAPE)) {
         quit = true;
         break;
      }
      if (ev.type == ALLEGRO_EVENT_DISPLAY_RESIZE) {
         al_acknowledge_resize(display);
      }
      if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
         if (ev.keyboard.keycode == ALLEGRO_KEY_F) {
            ToggleFullscreen();
         }
         if (ev.keyboard.keycode == ALLEGRO_KEY_M) {
            al_set_display_flag(display , ALLEGRO_MAXIMIZED , true);
         }
         if (ev.keyboard.keycode == ALLEGRO_KEY_N) {
            al_set_display_flag(display , ALLEGRO_MAXIMIZED , false);
         }
         if (ev.keyboard.keycode == ALLEGRO_KEY_O) {
            if (!UseOpenGL()) {
               printf("Failed to create an opengl context.\n");
               quit = true;
               break;
            }
         }
         if (ev.keyboard.keycode == ALLEGRO_KEY_D) {
            if (!UseDirect3D()) {
               printf("Failed to create a Direct3D context.\n");
               quit = true;
               break;
            }
         }
         for (int i = 0 ; i < al_get_num_video_adapters() ; ++i) {
            if (ev.keyboard.keycode == ALLEGRO_KEY_1 + i) {
               if (!SetAdapter(i)) {
                  printf("Failed to set adapter %d.\n" , i);
                  quit = true;
                  break;
               }
            }
         }
      }
      if (ev.type == ALLEGRO_EVENT_TIMER) {
         redraw = true;
      }
         
   } while (!al_is_event_queue_empty(queue));
}




void Display::Draw() {
   if (redraw) {
      al_set_target_backbuffer(display);
      al_clear_to_color(al_map_rgb(0,0,0));
      
      DisplayInfo();
      
      al_flip_display();

      redraw = false;
   }
}



void Display::Run() {
   while (!quit) {
      Draw();
      CheckInput();
   }
}

5 de outubro de 2020

Partindo do principio que você deseja desenvolver um sistema operacional do zero deve ter um conhecimento bastante razoável de C++, Assembly e hardware. Acredito que uma boa forma de aprender é estudar o código de quem o fez, tente procurar nos repositórios do GitHub pequenos projetos, pode ser uma boa para tentar entender como funciona o desenvolvimento de um SO na pratica.

Aqui pode ser um bom ponto de partida: https://wiki.osdev.org/Main_Page

9 de agosto de 2020

Entendi você quer fazer um jogo no console.. é possível tem que criar um handle para console window.

Seguindo aquele exemplo mas sem abrir janela gráfica, processamento de mensagens etc etc

#include <windows.h>

static COLORREF redColor=RGB(255,0,0);
static COLORREF blueColor=RGB(0,0,255);
static COLORREF greenColor=RGB(0,255,0);

/* SetPixel */
void setPixel(int x,int y,COLORREF& color=redColor)
{
	HWND console = GetConsoleWindow();
	HDC hdc = GetDC(console);
	SetPixel(hdc,x,y,color);
	ReleaseDC(console, hdc);
	return;
}

void drawLineBresenham(int xa, int ya, int xb, int yb)
{
	int dx = abs(xa - xb), dy = abs(ya - yb);
	int p = 2 * dy - dx;
	int twoDy = 2 * dy, twoDyDx = 2 * (dy - dx);
	int x, y, xEnd;

	if (xa > xb) {
		x = xb;
		y = yb;
		xEnd = xa;
	} else {
		x = xa;
		y = ya;
		xEnd = xb;
	}

	setPixel(x, y);

	while(x < xEnd) {
		x++;
		if(p < 0)
			p += twoDy;
		else {
			y++;
			p += twoDyDx;
		}
		setPixel(x, y);
	}
}

int main()
{
    drawLineBresenham(10, 20, 250, 300);
    return 0;
}

8 de agosto de 2020

Aqui tem um exemplo de como usar SetPixel para desenhar linhas através do algoritmo de Bresenham. Talvez ajude.

#include <windows.h>
#include <cmath>
#define ROUND(a) ((int) (a + 0.5))

/* set window handle */

static HWND sHwnd;
static COLORREF redColor=RGB(255,0,0);
static COLORREF blueColor=RGB(0,0,255);
static COLORREF greenColor=RGB(0,255,0);

void SetWindowHandle(HWND hwnd)
{
	sHwnd=hwnd;
}

/* SetPixel */
void setPixel(int x,int y,COLORREF& color=redColor)
{
	if(sHwnd==NULL) {
		MessageBox(NULL,"sHwnd was not initialized !","Error",MB_OK|MB_ICONERROR);
		exit(0);
	}

	HDC hdc=GetDC(sHwnd);
	SetPixel(hdc,x,y,color);
	ReleaseDC(sHwnd,hdc);
	return;

// NEVERREACH //
}

void drawLineBresenham(int xa, int ya, int xb, int yb)
{
	int dx = abs(xa - xb), dy = abs(ya - yb);
	int p = 2 * dy - dx;
	int twoDy = 2 * dy, twoDyDx = 2 * (dy - dx);
	int x, y, xEnd;

	if (xa > xb) {
		x = xb;
		y = yb;
		xEnd = xa;
	} else {
		x = xa;
		y = ya;
		xEnd = xb;
	}

	setPixel(x, y);

	while(x < xEnd) {
		x++;
		if(p < 0)
			p += twoDy;
		else {
			y++;
			p += twoDyDx;
		}

		setPixel(x, y);
	}
}

/* Window Procedure WndProc */

LRESULT CALLBACK WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	switch(message) {
		case WM_PAINT:
			SetWindowHandle(hwnd);
			drawLineBresenham(10, 20, 250, 300);
			break;
		case WM_CLOSE: // FAIL THROUGH to call DefWindowProc
			break;
		case WM_DESTROY:
			PostQuitMessage(0);
			return 0;
		default:
			break; // FAIL to call DefWindowProc //
	}
	return DefWindowProc(hwnd,message,wParam,lParam);
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int iCmdShow)
{
	static TCHAR szAppName[] = TEXT("Straight Line");
	WNDCLASS wndclass;
	wndclass.style         = CS_HREDRAW|CS_VREDRAW ;
	wndclass.lpfnWndProc   = WndProc ;
	wndclass.cbClsExtra    = 0 ;
	wndclass.cbWndExtra    = 0 ;
	wndclass.hInstance     = hInstance ;
	wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
	wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
	wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
	wndclass.lpszMenuName  = NULL ;
	wndclass.lpszClassName = szAppName ;

	// Register the window //

	if(!RegisterClass(&wndclass)) {
		MessageBox(NULL,"Registering the class failled","Error",MB_OK|MB_ICONERROR);
		exit(0);
	}

	// CreateWindow //

	HWND hwnd=CreateWindow(szAppName,"Bresenham's Algorithm - Programming Techniques",
	                       WS_OVERLAPPEDWINDOW,
	                       CW_USEDEFAULT,
	                       CW_USEDEFAULT,
	                       CW_USEDEFAULT,
	                       CW_USEDEFAULT,
	                       NULL,
	                       NULL,
	                       hInstance,
	                       NULL);

	if(!hwnd) {
		MessageBox(NULL,"Window Creation Failed!","Error",MB_OK);
		exit(0);
	}

	// ShowWindow and UpdateWindow //
	ShowWindow(hwnd,iCmdShow);
	UpdateWindow(hwnd);

	// Message Loop //
	MSG msg;

	while(GetMessage(&msg,NULL,0,0)) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	/* return no error to the operating system */
	return 0;
}

3 de agosto de 2020

Isso pode ajudar, na essência esse VisualG é um compilador pascal traduzido, ele não deve possuir todos os recursos da linguagem pascal mas com esse referencia fica fácil você fazer a transição.

https://fdocumentos.tips/document/transicao-do-pascal-para-c.html

1 de agosto de 2020

Existe também o livro introdutório de C++ do Bjarne Stroustrup: Princípios e Práticas de Programação com C++, já vi dele sendo vendido em sebos online por preços mais camaradas, um que que tem boas recomendações em forums e lista de melhores livros é o C++ Primer, 5th Edition do Stanley B. Lippma.

Esse link pode ajudar:

https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list

23 de julho de 2020

Acho que depende do seu gosto pessoal, se gosta do Python tem muitas opções para desenvolvimento de jogos, tem o PyGame, Cocos2d, a Godot engine que usa GDScript(baseado em python), a Panda3d fora versões de bibliotecas gráficas consagradas do C/C++ que foram portadas para o Python: PyOpenGL, PySFML, PySDL2 entre muitas outras.

Agora acredito que quando se fala em desenvolvimento de jogos não tem como não falar em C++, praticamente toda grande e pequena engine mesmo que use scripts baseados em outras linguagens é construída em C++, fora que C++ é sintaxe base para muitas linguagens o que facilita para você programar em outras linguagens. Outro ponto importante é que as duas engines mais populares usam C++ e C# que é caso da Unreal e da Unity, o que também pode influenciar no aprendizado visto que a demanda de materiais para estudo(cursos, youtube, livros) é maior.

23 de julho de 2020

Citação

Acompanhou a discussão toda? São vários pre-requisitos para voltar no tempo. Não basta um programa e uma biblioteca.

Sim... época diferente.. Não lembro onde li que os caixas eletrônicos nos anos 90 usavam essa conio para exibir as telas gráficas mas como você bem mencionou naquele tempo os programadores tinham acesso sem restrição ao hardware.

23 de julho de 2020

Engraçado no TC da pra montar umas telinhas apenas passando os códigos ascii, tentei reproduzir o mesmo no Windows 10 com a conio2.h (implementação da antiga conio.h para sistemas Windows) e não funciona.

Mesmo passando os códigos certos o console do Windows parece não aceitar.

Aqui o código para rodar TURBO C++ 3.0 emulado com DOSBOX... É fui longe com a arqueologia agora hehe...

#include<stdio.h>
#include<dos.h>
#include<ctype.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>

void main()
{
	clrscr();
	_setcursortype(_NOCURSOR);
	textcolor(WHITE);
	cprintf("\n   ┌─────────────────────────────────────────────────────────────────────────┐  ");
	for(int i=0;i<17;i++)
	cprintf("   │                                                                         │  ");
	cprintf("   └─────────────────────────────────────────────────────────────────────────┘  ");
	cprintf("   ┌──────────────────────┐                                ┌─────────────────┐  ");
	cprintf("   │       J O G O        │   Pressione 'X' para Sair      │ PONTOS: 0       │  ");
	cprintf("   └──────────────────────┘                                │ VIDAS.: 2       │  ");
	cprintf("                                                           └─────────────────┘  ");
	while(1)
	{

		char ch=getch();
		switch(tolower(ch))
		{
			case 'x' : return;
		}
	}
}   // main

22 de julho de 2020

Eu tenho essa função aqui que faz aquele tipo de moldura, com certeza da pra melhorar. Veja se ajuda.

#include <stdio.h>
#include <windows.h>

void gotoxy(int x, int y)
{
    HANDLE hCon;
    COORD dwPos;

    dwPos.X = x;
    dwPos.Y = y;
    hCon = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(hCon,dwPos);
}

void retangulo()
{
     // Linhas horizontais
     for(int i=2; i < 78; i++){
        gotoxy (i, 3); printf ("%c", 205);
        gotoxy(i, 23); printf ("%c", 205);
     }
     // Linhas verticais
     for(int v=4; v < 23; v++){
        gotoxy (2,v);  printf ("%c", 186);
        gotoxy(77,v);  printf ("%c", 186);
     }
     // Cantos
     gotoxy  (2,3);    printf ("%c", 201);
     gotoxy (2,23);    printf ("%c", 200);
     gotoxy (77,3);    printf ("%c", 187);
     gotoxy(77,23);    printf ("%c", 188);
}

int main()
{
    retangulo();
    return 0;
}

9 de julho de 2020

o C tem um desenvolvimento mais lento, tivemos o C11 em 2011 e depois o C18 em 2018.

O grupo de trabalho do C++ é mais atuante, a linguagem vem passando por constantes atualizações desde de 98 mas acredito que não da pra fazer uma comparação direta com o Python porque são nichos diferentes.

Enquanto Python visa abstração máxima mas paga o´preço quanto a velocidade e performance, o C++ visa alta performance e velocidade trabalhando mais próximo da maquina portanto o desenvolvimento de cada uma segue rumos totalmente diferentes, não espere ver comandos que só falta a se escreverem sozinhos em C++, logicamente a não ser que alguém o faça hehe

https://isocpp.org/

4 de julho de 2020

Acho que esse console graphics do Dev C++ usa uma versão portada da BGI(Borland Graphics Interface) dos sistemas MSDOS para Windows, procure por BGI para aprender os comandos para o desenhos de formas geométricas primitivas, linhas, círculos etc etc

Ou tentar partir para algo mais moderno SDL2, SFML porém já que parece que seu curso usou esse sistema melhor não inventar moda hehe.

2 de julho de 2020

C e C++ não tem esse tipo de possibilidade nativamente, para Windows você pode usar bibliotecas que são usadas para desenvolvimento daqueles jogos RPG em modo console.

Essa por ex: https://tapiov.net/rlutil/

Esse código gera o exemplo acima..

#include "rlutil.h"
#include <stdlib.h> // for srand() / rand()
#include <stdio.h>
#include "math.h"

#ifndef min
#define min(a,b) (((a)<(b))?(a):(b))
#endif // min

/// Tiles
#define FLOOR 0
#define WALL 1
#define COIN (1 << 1)
#define STAIRS_DOWN (1 << 2)
#define TORCH (1 << 4)

#define MAPSIZE 15

/// Globals
int x, y;
int coins = 0, moves = 0, torch = 30, level = 1;
int lvl[MAPSIZE][MAPSIZE];

/// Generates the dungeon map
void gen(int seed) {
	srand(seed);
	int i, j;
	for (j = 0; j < MAPSIZE; j++) {
		for (i = 0; i < MAPSIZE; i++) {
			if (i == 0 || i == MAPSIZE-1 || j == 0 || j == MAPSIZE-1 ||
			  rand() % 10 == 0) lvl[i][j] = 1;
			else if (rand() % 20 == 0) lvl[i][j] = COIN;
			else if (rand() % 100 == 0) lvl[i][j] = TORCH;
			else lvl[i][j] = 0;
		}
	}
	#define randcoord (1+rand()%(MAPSIZE-2))
	x = randcoord;
	y = randcoord;
	lvl[randcoord][randcoord] = STAIRS_DOWN;
	#undef randcoord
}

/// Draws the screen
void draw() {
	cls();
	locate(1, MAPSIZE + 1);
	setColor(YELLOW);
	printf("Coins: %d\n", coins);
	setColor(RED);
	printf("Torch: %d\n", torch);
	setColor(MAGENTA);
	printf("Moves: %d\n", moves);
	setColor(GREEN);
	printf("Level: %d\n", level);
	locate(1, 1);
	int i, j;
	for (j = 0; j < MAPSIZE; j++) {
		for (i = 0; i < MAPSIZE; i++) {
			if (0); //(i == x && j == y) printf("@");
			else if (abs(x-i)+abs(y-j)>min(10,torch/2)) printf(" ");
			else if (lvl[i][j] == 0) { setColor(BLUE); printf("."); }
			else if (lvl[i][j] & WALL) { setColor(CYAN); printf("#"); }
			else if (lvl[i][j] & COIN) { setColor(YELLOW); printf("o"); }
			else if (lvl[i][j] & STAIRS_DOWN) { setColor(GREEN); printf("<"); }
			else if (lvl[i][j] & TORCH) { setColor(RED); printf("f"); }
		}
		printf("\n");
	}
	locate(x+1, y+1);
	setColor(WHITE);
	printf("@");
	fflush(stdout);
}

/// Main loop and input handling
int main() {
	hidecursor();
	saveDefaultColor();
	gen(level);
	setColor(2);
	printf("Welcome! Use WASD to move, ESC to quit.\n");
	setColor(6);
	anykey("Hit any key to start.\n");
	draw();
	while (1) {
		// Input
		if (kbhit()) {
			char k = getkey();

			int oldx = x, oldy = y;
			if (k == 'a') { --x; ++moves; }
			else if (k == 'd') { ++x; ++moves; }
			else if (k == 'w') { --y; ++moves; }
			else if (k == 's') { ++y; ++moves; }
			else if (k == KEY_ESCAPE) break;
			// Collisions
			if (lvl[x][y] & WALL) { x = oldx; y = oldy; }
			else if (lvl[x][y] & COIN) { coins++; lvl[x][y] ^= COIN; }
			else if (lvl[x][y] & TORCH) { torch+=20; lvl[x][y] ^= TORCH; }
			else if (lvl[x][y] & STAIRS_DOWN) gen(++level);
			// Drawing
			draw();
			// Die
			if (--torch <= 0) break;
		}
	}

	cls();
	resetColor();
	showcursor();

	return 0;
}

2 de julho de 2020

Uma boa forma de entender como o algorítimo funciona é que matematicamente falando é uma propriedade distributiva, o elemento que esta no v[1] vai ser comparado com o v[2], v[3], v[4] ate o final, a partir disso o elemento que esta no v[2] não precisa mais ser comparado com o elemento que esta em v[1] porque já foi previamente comparado precisando apenas ser comparado com vetor[3], vetor[4] e assim por diante.

27 de junho de 2020

Eu uso a rlutil, ela é uma especie de sucessora espiritual da conio2.

Bastante simples o uso basta incluir o header, funciona em C++ e C, ela detecta automaticamente e ajusta o código.

No repositório tem exemplos de C e C++.

https://github.com/tapio/rlutil

16 de junho de 2020

Infelizmente não é tão simples assim...

Você pode usar uma biblioteca para esse fim ou criar um programa que gera toda a estrutura que define um arquivo PDF mas para tal façanha teria que estudar o padrão do formato PDF. Felizmente a Adobe disponibiliza o documento de graça mas como pode ver tem mais de 700 paginas.

https://www.adobe.com/devnet/pdf/pdf_reference.html

30 de março de 2020

Acho que esse primeiro código dele não aparece nada porque ele tentou implementar uma especie de "blit" que copia uma superfície para outra, só que não tenha certeza se com esses comandos que ele usou tinha algo na memoria para ser copiado para a superfície screen. No SDL2 eu uso a biblioteca SDL_image para manipular imagens, implementar esse blit na "unha" não deve ser tão simples assim já que envolve enviar os padrões, imagens ou matrizes com as imagens desenhadas pixel a pixel como faziam antigamente para a memoria e fazer a copia entre superfícies.

Adaptando o programa dele em SDL1 seria mais ou menos assim.

#include <SDL/SDL.h>

int main(int argc, char** argv)
{
    printf("Iniciando SDL...\n");

    SDL_Surface *screen, *retangulo; //cria uma surface SDL

    screen = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); //inicia o vídeo

    Uint32 color = SDL_MapRGB(screen->format, 255,0,0);

    printf("SDL iniciado...\n");

    retangulo = SDL_LoadBMP("rect.bmp");

    SDL_Event event;
    while(1) {
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
            case SDL_KEYDOWN: { //caso alguma tecla seja pressionada
                switch (event.key.keysym.sym) { //para detectar a tecla pressionada
                case SDLK_ESCAPE:
                    printf("ESC pressionado.\n");
                    exit(0);
                    break;
                case SDLK_UP:
                    printf("Seta para cima pressionanda.\n");
                    exit(0);
                    break;
                case SDLK_a:
                    printf("A pressionado.\n");
                    exit(0);
                    break;
                }
                break;
            }
            }
            if(event.type == SDL_QUIT) { //fecha através do botão fechar
                printf("Fechado pelo botão fechar...\n");
                exit(0);
            }
        }

        SDL_FillRect(screen, &screen->clip_rect, color);
        SDL_BlitSurface(retangulo, NULL, screen, NULL);
        SDL_Flip(screen);

    }
    SDL_FreeSurface(retangulo);
    SDL_Quit();
    return 0;
}

rect.bmp

Entrar

Artigos

Selos

Fabricantes

Livros

Cursos

Análises

Fórum

posts postados por Benjamin Breeg

Sobre o Clube do Hardware

Direitos autorais

Mais