Não existe algo mais poderoso para fazer um jogo que usar C/C++, porém, esse poder tem um preço e não é barato. É a dificuldade que você terá que aprender talvez a linguagem mais hermética de alto nível (alguns autores chamam de médio) que há.
Antigamente programar nessas linguagens ou era a única opção ou a única que trazia de fato uma performance boa para os jogos. Então ou os devs usavam C ou partiam para ASM direto, caso a máquina suportava um pouco mais de memória, usavam o C++.
Como os hardware de hoje são mais parrudos e longe das limitações que existiam na década de 90 e as ferramentas de programação para jogos evoluíram e surgiram as engines, pode-se usar linguagens mais práticas e fáceis que o desempenho não será efetivamente comprometido, principalmente se os jogos forem mais simples.
Eu costumo chamar C/C++ de linguagens da Bomba H, já que a bomba de hidrogênio precisa ser acionada por uma bomba atômica anterior para que o seu processo de fusão ocorra. Em C/C++ geralmente você terá que aprender outras linguagens de programação / marcação para conseguir utilizá-las.
Exemplo: se eu for compilar um projeto que faço em Java numa IntelliJ IDEA, a própria ferramenta me dá o suporte fácil para eu compilar o meu projeto, é quase que automático. Em C/C++ você geralmente precisa aprender a gerar um makefile via toolchain usando alguma linguagem para isso, é como se eu precisasse de uma linguagem para dizer para o compilar de como ele tem que interpretar e compilar aquele código que eu escrevi em C/C++. Isso afasta gente pra c***lho porque você pode levar até dias para conseguir fazer o seu projeto ser entendido pelo compilador.
É uma bomba H precisando de uma bomba atômica para a coisa toda funcionar.
Vou dar um exemplo prático:
Eu tenho alguns projetos usando SDL que é library escrita em C para programação de jogos 2D quase em baixo nível, mas que consegue encapsular APIs gráficas como OpenGL e DirectX. Para eu conseguir fazer o meu computador reconhecer a library, o OpenGL, a versão do C++ que o meu compilador irá trabalhar e o destino, terei que explicitamente determinar esses parâmetros:
Código:
cmake_minimum_required(VERSION 3.14)
project(ray)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_FLAGS "-Wall")
include("${CMAKE_SOURCE_DIR}/Source.cmake")
set(CMAKE_MODULE_PATH "~/dev/c++/sdl/cmake_module")
find_package(SDL2 REQUIRED)
find_package(SDL2_Image REQUIRED)
find_package(SDL2_Mixer REQUIRED)
find_package(SDL2_ttf REQUIRED)
include_directories(${SDL2_INCLUDE_DIR} ${SDL2_IMAGE_INCLUDE_DIR} ${SDL2_MIXER_INCLUDE_DIR} ${SDL2_TTF_INCLUDE_DIR})
set(SDL_LIBRARIES ${SDL2_LIBRARY} ${SDL2_IMAGE_LIBRARY} ${SDL2_MIXER_LIBRARY} ${SDL2_TTF_LIBRARY})
add_executable(${PROJECT_NAME} ${SOURCE_FILES})
target_link_libraries(${PROJECT_NAME} ${SDL_LIBRARIES})
O código acima é um exemplo de um CMake File no formato txt.
Eu informo a versão do meu toolchain na primeira linguagem, posso colocar como obrigatório, no caso, não deixei;
Depois informo o nome do projeto;
Depois, a versão do C++ usado que é 14 (o meu computador é compatível com a 17, também)
Seto parâmetros para mostrar os warnings;
Indico onde eu deixei os arquivos de compilação
Informo a onde ele deve procurar outros arquivos no formato .cmake para dar continuidade do processo de compilação
Informo o que eu vou querer compilar junto com o meu projeto usando find_package(...)
Informo que as libs externas devem compilar e os seus resultados serem colocados com o meu projeto
E aí vai..
O exemplo abaixo é de um editor de textos que fiz em C++, novamente, se vc for usar C/C++ vai precisar lidar com essa outra linguagem para fazer o seu projeto funcionar:
Código:
#[[
CMAKE - Build File: Macacos Me Mordam
@author: Ino<NÃO VOU POR TODO O NOME AQUI>
@date: 04/18/2019
Macacos Me Mordam (MMM) is just a simple BBForum Editor.
This make file is required to compile under CMake Tools.
You have to specify new entries for your custom setup:
- Qt5_DIR: enter the path of Qt5 CMake installation. Instead to use this solution,
you can provide CMAKE_PREFIX_PATH to compiler settings location.
- find_package(Qt5 REQUIRED COMPONENTS <...>) enter extra components if you need to.
]]
cmake_minimum_required(VERSION 3.10)
project(mmm)
set(CMAKE_CXX_STANDARD 14)
# Find includes in corresponding build directories
set(CMAKE_INCLUDE_CURRENT_DIR ON)
# Instruct CMake to run moc automatically when needed
set(CMAKE_AUTOMOC ON)
# Create code from a list of Qt designer ui files
set(CMAKE_AUTOUIC ON)
# NEW Include Resource files
set(CMAKE_AUTORCC ON)
# NEW CMaker Prefix Path
set(CMAKE_PREFIX_PATH /Users/nihil/Qt/5.12.3/clang_64)
# NEW Export Commands to JSON file
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# Find the Qt5 components
set(Qt5_DIR /Users/nihil/Qt/5.12.3/clang_64/lib/cmake/Qt5)
# Find Qt5 CMake files based on Qt5_DIR path
find_package(Qt5 REQUIRED COMPONENTS Core Widgets Gui)
# Project Headers
set(project_headers
src/mainwindow.h
src/highlighter.h
src/filehandler.h
src/textproperties.h
src/token.h
src/config.h)
# Project Sources
set(project_sources
src/main.cpp
src/mainwindow.cpp
src/highlighter.cpp
src/textproperties.cpp
src/token.cpp
src/config.cpp)
# This wrapp is needed to compile QT_OBJECT Meta Object Component in header files
qt_wrap_cpp(project_qt_wrap ${project_headers})
# Executable
# MACOSX_BUNDLE
add_executable(${PROJECT_NAME} ${project_headers} ${project_sources} ${project_qt_wrap})
# Link Qt5 libraries after the building process (must be after add_executable() function)
target_link_libraries(${PROJECT_NAME}
PUBLIC
Qt5::Core
Qt5::Widgets
Qt5::Gui
)
A vantagem de pegar um C#, Java, GML da vida é não ter que lidar com essa joça de toolchain. No mundo Java até temos alguns como Maven e Gradle, mas são bem mais simples e muitas das coisas que se usa e programa nela já são automatizadas.
Enfim, hoje em dia dá para fugir de C/C++ tranquilamente, ou se você é maluco(a) como eu, aprenda a usar sapo@#! e faça uma engine.
NOTA: Em Windows usando MSVC vc dá para fugir dessa toolchain e pedir para a sua IDE gerar o código, mas não é tão seamless também e terá que configurar para cada projeto.
