Capítulo 2 — Preparando o Ambiente de Desenvolvimento com MonoGame

PorAlexandre Porfírio — Tríade da Riqueza Digital

Introdução: antes de criar o jogo, prepare a base certa

Cri­ar jogos com MonoGame não começa no per­son­agem, no mapa, no inimi­go ou no sis­tema de col­isão. Começa antes: no ambi­ente de desen­volvi­men­to.

Um ambi­ente bem con­fig­u­ra­do evi­ta horas de frus­tração. Quan­do o .NET está insta­l­a­do cor­re­ta­mente, o edi­tor está prepara­do, os tem­plates do MonoGame fun­cionam e o pro­je­to roda sem erros, você con­segue focar no que real­mente impor­ta: apren­der a con­stru­ir jogos.

No capí­tu­lo ante­ri­or, enten­demos que o MonoGame é um frame­work de desen­volvi­men­to de jogos em C#/.NET. Ele não é uma engine visu­al como Uni­ty ou Godot. O MonoGame segue uma abor­dagem mais dire­ta, basea­da em códi­go. A doc­u­men­tação ofi­cial descreve o MonoGame como um frame­work .NET para cri­ar jogos para desk­top, con­soles e dis­pos­i­tivos móveis usan­do C#.

Neste capí­tu­lo, o obje­ti­vo é preparar o ter­reno para os próx­i­mos pas­sos. Você vai enten­der:

✅ quais fer­ra­men­tas insta­lar;
✅ qual edi­tor escol­her;
✅ como insta­lar os tem­plates do MonoGame;
✅ como cri­ar o primeiro pro­je­to;
✅ como rodar o jogo;
✅ como orga­ni­zar as pas­tas;
✅ como enten­der a estru­tu­ra ini­cial;
✅ como preparar o Con­tent Pipeline;
✅ quais erros comuns evi­tar.

A ideia é sim­ples: ao final deste capí­tu­lo, você pre­cisa ter um pro­je­to MonoGame rodan­do na sua máquina.

🎮 O que significa “preparar o ambiente” para MonoGame?

Preparar o ambi­ente sig­nifi­ca con­fig­u­rar tudo que você pre­cisa para pro­gra­mar, com­pi­lar, exe­cu­tar e orga­ni­zar um jogo.

No caso do MonoGame, a base envolve:

Fer­ra­men­taPara que serve
.NET SDKPer­mite cri­ar, com­pi­lar e exe­cu­tar pro­je­tos em C#/.NET
Edi­tor ou IDEAmbi­ente onde você escreve e orga­ni­za o códi­go
Tem­plates do MonoGameMod­e­los pron­tos para cri­ar pro­je­tos MonoGame
MGCB / Con­tent PipelineSis­tema para orga­ni­zar e proces­sar assets como ima­gens, sons e fontes
Ter­mi­nalUsa­do para cri­ar pro­je­tos, insta­lar tem­plates e rodar coman­dos
GitCon­t­role de ver­são para sal­var a evolução do pro­je­to

O MonoGame se inte­gra ao fluxo comum de desen­volvi­men­to .NET. A doc­u­men­tação ofi­cial reforça essa difer­ença: em vez de ser um pro­gra­ma visu­al inde­pen­dente como algu­mas engines, ele se encaixa em um fluxo de desen­volvi­men­to basea­do em códi­go.

Essa é uma difer­ença impor­tante. Você não abre o MonoGame como abre uma engine visu­al. Você cria um pro­je­to .NET com MonoGame e tra­bal­ha no códi­go.

🧱 A base de tudo: instalar o .NET SDK

O primeiro pas­so é insta­lar o .NET SDK.

Não con­fun­da SDK com Run­time.

Runtime

O Run­time serve para exe­cu­tar apli­cações .NET já prontas.

SDK

O SDK serve para cri­ar, com­pi­lar, tes­tar e exe­cu­tar apli­cações .NET durante o desen­volvi­men­to.

Para cri­ar jogos com MonoGame, você pre­cisa do SDK, não ape­nas do Run­time.

A doc­u­men­tação ofi­cial da Microsoft expli­ca que o .NET pode ser insta­l­a­do no Win­dows, Lin­ux e macOS e reúne as dependên­cias necessárias para desen­volver, implan­tar e exe­cu­tar apli­cações .NET.

O .NET é uma platafor­ma gra­tui­ta, open-source e mul­ti­platafor­ma para cri­ar difer­entes tipos de apli­cações. A doc­u­men­tação da Microsoft tam­bém desta­ca que C# é a lin­guagem mais pop­u­lar nesse ecos­sis­tema.

Como verificar se o .NET está instalado

Depois da insta­lação, abra o ter­mi­nal e dig­ite:

dotnet --version

Se apare­cer um número de ver­são, o SDK está insta­l­a­do.

Exem­p­lo:

10.0.201

Você tam­bém pode lis­tar os SDKs insta­l­a­dos:

dotnet --list-sdks

E os run­times:

dotnet --list-runtimes

Qual versão instalar?

O ide­al é insta­lar uma ver­são atu­al e supor­ta­da do .NET SDK. A pági­na ofi­cial de down­loads da Microsoft mostra os pacotes para Win­dows, Lin­ux e macOS, incluin­do SDKs e run­times.

Para evi­tar prob­le­mas, use sem­pre uma ver­são estáv­el do SDK e con­fi­ra a com­pat­i­bil­i­dade com os tem­plates do MonoGame que você vai insta­lar.

🖥️ Escolhendo a IDE: Visual Studio, VS Code ou Rider?

Você pode desen­volver com MonoGame em difer­entes ambi­entes.

Os mais comuns são:

  • Visu­al Stu­dio;
  • Visu­al Stu­dio Code;
  • Jet­Brains Rid­er.

Cada um tem van­ta­gens.

🟦 Visual Studio

O Visu­al Stu­dio é uma opção forte para quem usa Win­dows.

Van­ta­gens:

✅ óti­ma inte­gração com C#;
✅ depu­ração forte;
✅ Intel­liSense avança­do;
✅ geren­ci­a­men­to visu­al de pro­je­tos;
✅ boa exper­iên­cia com .NET;
✅ inte­gração com exten­sões.

A doc­u­men­tação do MonoGame infor­ma que a par­tir do MonoGame 3.8.1 existe uma exten­são opcional para Visu­al Stu­dio 2022 que insta­la tem­plates e ofer­ece aces­so rápi­do ao MGCB Edi­tor.

Para quem está começan­do no Win­dows, Visu­al Stu­dio é provavel­mente o cam­in­ho mais con­fortáv­el.

🟩 Visual Studio Code

O VS Code é mais leve e fun­ciona bem em Win­dows, Lin­ux e macOS.

Van­ta­gens:

✅ leve;
✅ mul­ti­platafor­ma;
✅ bom ter­mi­nal inte­gra­do;
✅ exten­sões para C#;
✅ ide­al para quem gos­ta de fluxo por lin­ha de coman­do.

A doc­u­men­tação ofi­cial do MonoGame tem instruções especí­fi­cas para con­fig­u­rar o ambi­ente no VS Code, incluin­do o coman­do para insta­lar os tem­plates do MonoGame.

Para quem quer apren­der o fluxo real de ter­mi­nal e pro­je­tos .NET, VS Code é exce­lente.

🟧 JetBrains Rider

O Rid­er é uma IDE com­er­cial muito forte para .NET.

Van­ta­gens:

✅ exce­lente suporte a C#;
✅ refa­toração avança­da;
✅ boa orga­ni­za­ção de pro­je­tos;
✅ mul­ti­platafor­ma;
✅ depu­ração robus­ta.

É uma óti­ma escol­ha para quem já tra­bal­ha profis­sion­al­mente com C# ou pref­ere fer­ra­men­tas da Jet­Brains.

🧭 Minha recomendação para iniciantes

Se você usa Win­dows e está começan­do:

Use Visu­al Stu­dio 2022.

Se você quer algo leve e mul­ti­platafor­ma:

Use VS Code.

Se você já é mais avança­do e tra­bal­ha com .NET:

Rid­er pode ser exce­lente.

O impor­tante é não perder tem­po demais escol­hen­do fer­ra­men­ta. O mel­hor ambi­ente é aque­le que per­mite rodar o pro­je­to e escr­ev­er códi­go com clareza.

⚙️ Instalando os templates do MonoGame

Depois de insta­lar o .NET SDK, você pre­cisa insta­lar os tem­plates do MonoGame.

Tem­plates são mod­e­los de pro­je­to. Eles per­mitem cri­ar rap­i­da­mente um pro­je­to MonoGame usan­do o coman­do dotnet new.

A doc­u­men­tação ofi­cial de con­fig­u­ração no VS Code ori­en­ta insta­lar os tem­plates com este coman­do:

dotnet new install MonoGame.Templates.CSharp

Esse coman­do insta­la os mod­e­los de pro­je­to C# do MonoGame no seu ambi­ente .NET.

Depois de insta­lar, você pode ver­i­ficar se os tem­plates estão disponíveis:

dotnet new list monogame

Depen­den­do da ver­são insta­l­a­da, você poderá ver tem­plates como:

MonoGame Cross-Platform Desktop Application
MonoGame Windows DirectX Application
MonoGame Android Application
MonoGame iOS Application
MonoGame Shared Library

A doc­u­men­tação ofi­cial expli­ca que o MonoGame tra­bal­ha com difer­entes platafor­mas-alvo e que cada platafor­ma pos­sui seu próprio tem­plate de pro­je­to.

🖥️ Qual template escolher no começo?

Para começar, o mais recomen­da­do é o Desk­topGL.

A doc­u­men­tação ofi­cial expli­ca que a platafor­ma Desk­topGL pode ser usa­da para cri­ar jogos que rodam em Win­dows, macOS ou Lin­ux com a mes­ma base de códi­go e pro­je­to.

Isso é per­feito para ini­ciantes.

Por quê?

✅ fun­ciona em desk­top;
✅ é mul­ti­platafor­ma;
✅ evi­ta com­plex­i­dades de mobile;
✅ não exige con­fig­u­ração de con­sole;
✅ per­mite focar no apren­diza­do do game loop.

O cam­in­ho ide­al é:

primeiro Desk­topGL, depois out­ras platafor­mas.

🚀 Criando seu primeiro projeto MonoGame

Depois de insta­lar o SDK e os tem­plates, crie uma pas­ta para seus pro­je­tos.

Exem­p­lo:

mkdir ProjetosMonoGame
cd ProjetosMonoGame

Ago­ra crie um pro­je­to Desk­topGL:

dotnet new mgdesktopgl -o MeuPrimeiroJogo

Entre na pas­ta:

cd MeuPrimeiroJogo

Rode o jogo:

dotnet run

Se tudo estiv­er cor­re­to, uma janela do jogo será aber­ta.

Mes­mo que a tela este­ja vazia ou com cor sól­i­da, isso já é uma vitória enorme: seu ambi­ente está fun­cio­nan­do.

🧠 O que aconteceu quando você rodou dotnet run?

O coman­do:

dotnet run

faz algu­mas coisas:

  1. lê o arqui­vo do pro­je­to;
  2. restau­ra dependên­cias;
  3. com­pi­la o códi­go;
  4. exe­cu­ta o jogo.

Em um pro­je­to MonoGame, isso abre uma janela grá­fi­ca e começa o loop do jogo.

Essa janela será a base onde você vai desen­har per­son­agens, cenários, menus, inimi­gos, mapas e inter­faces.

📁 Entendendo a estrutura inicial do projeto

Depois de cri­ar o pro­je­to, você verá arquiv­os pare­ci­dos com estes:

MeuPrimeiroJogo/
├── Content/
│   └── Content.mgcb
├── Game1.cs
├── Program.cs
├── MeuPrimeiroJogo.csproj
└── ...

Vamos enten­der cada parte.

Program.cs

Esse arqui­vo é o pon­to de entra­da da apli­cação.

Ele cria uma instân­cia do jogo e ini­cia sua exe­cução.

Algo pare­ci­do com:

using var game = new MeuPrimeiroJogo.Game1();
game.Run();

Esse arqui­vo nor­mal­mente não pre­cisa ser alter­ado no começo.

Game1.cs

Esse é o arqui­vo mais impor­tante no iní­cio.

Ele con­tém a classe prin­ci­pal do jogo.

É nele que você verá méto­dos como:

Initialize()
LoadContent()
Update()
Draw()

A doc­u­men­tação ofi­cial do tuto­r­i­al “Build­ing 2D Games with MonoGame” ded­i­ca um capí­tu­lo para explo­rar o arqui­vo Game1 ger­a­do ao cri­ar um novo pro­je­to MonoGame, jus­ta­mente porque ele é a base ini­cial da apli­cação.

No começo, é nor­mal tudo ficar den­tro do Game1.cs. Mas com o tem­po você vai sep­a­rar o códi­go em class­es como:

  • Play­er;
  • Ene­my;
  • Scene­M­an­ag­er;
  • Input­Man­ag­er;
  • Camera2D;
  • Ani­ma­tion;
  • GameS­tate;
  • Lev­el.

MeuPrimeiroJogo.csproj

Esse é o arqui­vo do pro­je­to .NET.

Ele infor­ma:

  • qual SDK usar;
  • quais pacotes estão insta­l­a­dos;
  • qual tipo de saí­da será ger­a­da;
  • quais pro­priedades de build exis­tem.

Você não pre­cisa mex­er muito nele no começo, mas é impor­tante saber que ele existe.

Pasta Content

A pas­ta Content é onde ficam assets do jogo.

Exem­p­los:

  • ima­gens;
  • spritesheets;
  • fontes;
  • sons;
  • músi­cas;
  • efeitos;
  • arquiv­os proces­sa­dos pelo pipeline.

Den­tro dela, você verá o arqui­vo:

Content.mgcb

Esse arqui­vo per­tence ao sis­tema de Con­tent Pipeline do MonoGame.

🧩 O que é o Content Pipeline?

Jogos usam muitos arquiv­os exter­nos: ima­gens, sons, fontes, mapas, tex­turas e out­ros recur­sos.

O Con­tent Pipeline serve para orga­ni­zar e proces­sar ess­es arquiv­os para que eles pos­sam ser car­rega­dos pelo jogo.

A doc­u­men­tação ofi­cial expli­ca que o MonoGame Con­tent Builder, ou MGCB, é uma fer­ra­men­ta de lin­ha de coman­do para con­stru­ir con­teú­do XNB em sis­temas desk­top como Win­dows, Mac e Lin­ux.

Tam­bém existe o MGCB Edi­tor, uma inter­face grá­fi­ca para orga­ni­zar e con­stru­ir pro­je­tos de con­teú­do do MonoGame. A doc­u­men­tação ofi­cial descreve o MGCB Edi­tor como o edi­tor GUI para pro­je­tos do MonoGame Con­tent Builder.

Em ter­mos sim­ples:

O Con­tent Pipeline prepara seus assets para serem usa­dos den­tro do jogo.

🎨 Por que não simplesmente carregar PNG direto?

Em alguns casos, é pos­sív­el car­regar arquiv­os dire­ta­mente. Mas o Con­tent Pipeline existe para padronizar e otimizar a for­ma como o jogo car­rega recur­sos.

Ele aju­da a:

✅ orga­ni­zar assets;
✅ con­vert­er arquiv­os;
✅ cri­ar con­teú­do proces­sa­do;
✅ reduzir prob­le­mas de car­rega­men­to;
✅ facil­i­tar dis­tribuição;
✅ man­ter o pro­je­to mais profis­sion­al.

No começo, parece buro­cráti­co. Depois você entende que ele evi­ta bagunça.

🖼️ Preparando a primeira textura

Nos próx­i­mos capí­tu­los, você vai car­regar sprites e desen­har ima­gens.

Por enquan­to, o impor­tante é enten­der que ima­gens devem ficar orga­ni­zadas.

Uma estru­tu­ra ini­cial boa seria:

Content/
├── sprites/
│   ├── player.png
│   ├── enemy.png
│   └── coin.png
├── backgrounds/
│   └── level1.png
├── audio/
│   ├── jump.wav
│   └── theme.ogg
└── fonts/
    └── default.spritefont

Mes­mo que o pro­je­to seja pequeno, orga­ni­za­ção des­de o iní­cio evi­ta dor de cabeça.

🛠️ Configurando o primeiro ajuste da janela

Depois de cri­ar o pro­je­to, você pode per­son­alizar a janela.

No Game1.cs, nor­mal­mente existe um cam­po pare­ci­do com:

private GraphicsDeviceManager _graphics;
private SpriteBatch _spriteBatch;

No con­stru­tor, você pode ajus­tar títu­lo e res­olução:

public Game1()
{
    _graphics = new GraphicsDeviceManager(this);
    Content.RootDirectory = "Content";
    IsMouseVisible = true;

    Window.Title = "Meu Primeiro Jogo com MonoGame";

    _graphics.PreferredBackBufferWidth = 1280;
    _graphics.PreferredBackBufferHeight = 720;
    _graphics.ApplyChanges();
}

Ago­ra rode:

dotnet run

Se tudo estiv­er cer­to, a janela abrirá em 1280x720 com o títu­lo per­son­al­iza­do.

Esse pequeno ajuste já ensi­na uma coisa impor­tante: em MonoGame, você con­tro­la o com­por­ta­men­to do jogo por códi­go.

🧠 Entendendo o ciclo básico: Initialize, LoadContent, Update e Draw

Mes­mo este capí­tu­lo sendo sobre ambi­ente, vale apre­sen­tar rap­i­da­mente o coração do pro­je­to.

Initialize

Usa­do para ini­cializar con­fig­u­rações gerais.

Exem­p­lo:

protected override void Initialize()
{
    base.Initialize();
}

Aqui você pode preparar var­iáveis, esta­dos ini­ci­ais e con­fig­u­rações que não depen­dem dire­ta­mente dos assets.

LoadContent

Usa­do para car­regar recur­sos.

Exem­p­lo:

protected override void LoadContent()
{
    _spriteBatch = new SpriteBatch(GraphicsDevice);
}

Nos próx­i­mos capí­tu­los, você car­regará tex­turas assim:

_playerTexture = Content.Load<Texture2D>("sprites/player");

Update

Usa­do para atu­alizar a lóg­i­ca do jogo.

Exem­p­lo:

protected override void Update(GameTime gameTime)
{
    base.Update(gameTime);
}

Aqui entram:

  • input;
  • movi­men­to;
  • col­isão;
  • pon­tu­ação;
  • vida;
  • inimi­gos;
  • timers;
  • regras do jogo.

Draw

Usa­do para desen­har na tela.

Exem­p­lo:

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);

    base.Draw(gameTime);
}

Aqui entram:

  • fun­do;
  • per­son­agens;
  • inimi­gos;
  • itens;
  • inter­face;
  • tex­tos.

Essa sep­a­ração é fun­da­men­tal.

Update pen­sa. Draw mostra.

📌 Organização profissional desde o começo

Um erro comum é deixar tudo den­tro do Game1.cs por tem­po demais.

No iní­cio, tudo bem. Mas rap­i­da­mente o pro­je­to vira bagunça.

Uma estru­tu­ra mais saudáv­el seria:

MeuPrimeiroJogo/
├── Content/
├── Core/
│   ├── InputManager.cs
│   ├── SceneManager.cs
│   └── GameSettings.cs
├── Entities/
│   ├── Player.cs
│   ├── Enemy.cs
│   └── Coin.cs
├── Scenes/
│   ├── MenuScene.cs
│   ├── GameScene.cs
│   └── GameOverScene.cs
├── UI/
│   ├── Button.cs
│   └── Hud.cs
├── Game1.cs
└── Program.cs

Você não pre­cisa cri­ar tudo ago­ra. Mas pen­sar nes­sa orga­ni­za­ção des­de o iní­cio aju­da muito.

🔧 Instalando e usando Git

Git não é obri­gatório para rodar MonoGame, mas é essen­cial para tra­bal­har com pro­je­to real.

Com Git, você con­segue:

✅ sal­var ver­sões do pro­je­to;
✅ voltar atrás se algo que­brar;
✅ cri­ar branch­es;
✅ tes­tar ideias;
✅ pub­licar no GitHub;
✅ mon­tar port­fólio.

Depois de cri­ar o pro­je­to, você pode ini­ciar um repositório:

git init

Crie um arqui­vo .gitignore para pro­je­tos .NET:

dotnet new gitignore

Depois salve o primeiro com­mit:

git add .
git commit -m "Projeto MonoGame inicial"

Isso cria uma lin­ha do tem­po do seu jogo.

🧪 Testando se o ambiente está realmente correto

Antes de avançar, faça este check­list:

✅ dotnet --version fun­ciona;
✅ tem­plates do MonoGame foram insta­l­a­dos;
✅ dotnet new mgdesktopgl cria pro­je­to;
✅ dotnet run abre a janela;
✅ você con­segue alter­ar títu­lo da janela;
✅ você con­segue alter­ar res­olução;
✅ o pro­je­to com­pi­la sem erros;
✅ o edi­tor recon­hece C#;
✅ o ter­mi­nal fun­ciona den­tro da pas­ta do pro­je­to;
✅ você sabe onde está o Game1.cs;
✅ você sabe onde está a pas­ta Content.

Se tudo isso está fun­cio­nan­do, seu ambi­ente está pron­to para o próx­i­mo capí­tu­lo.

🚨 Problemas comuns e como resolver

1. dotnet não é reconhecido

Erro comum:

'dotnet' não é reconhecido como um comando interno ou externo

Isso nor­mal­mente indi­ca que o .NET SDK não foi insta­l­a­do cor­re­ta­mente ou não está no PATH do sis­tema.

Solução:

  • rein­stale o .NET SDK;
  • feche e abra o ter­mi­nal;
  • reini­cie o com­puta­dor;
  • teste dotnet --version.

A doc­u­men­tação ofi­cial da Microsoft man­tém instruções sep­a­radas para insta­lação do .NET em Win­dows, Lin­ux e macOS.

2. Template mgdesktopgl não aparece

Se o coman­do abaixo não fun­cionar:

dotnet new mgdesktopgl -o MeuPrimeiroJogo

Instale nova­mente os tem­plates:

dotnet new install MonoGame.Templates.CSharp

Depois liste:

dotnet new list monogame

A doc­u­men­tação ofi­cial do MonoGame usa jus­ta­mente o pacote MonoGame.Templates.CSharp para insta­lação dos tem­plates.

3. Projeto criado, mas não roda

Tente restau­rar dependên­cias:

dotnet restore

Depois rode:

dotnet run

Se per­si­s­tir, con­fi­ra:

  • se você está den­tro da pas­ta cor­re­ta;
  • se o arqui­vo .csproj existe;
  • se o SDK está insta­l­a­do;
  • se as dependên­cias foram restau­radas;
  • se o erro aparece no ter­mi­nal.

4. Erro no Content Pipeline

Se o erro envolver Content.mgcb, MGCB ou assets, o prob­le­ma pode estar no pipeline de con­teú­do.

A doc­u­men­tação ofi­cial expli­ca que o MGCB é a fer­ra­men­ta usa­da para con­stru­ir con­teú­do em pro­je­tos MonoGame.

Soluções comuns:

  • ver­i­ficar se o arqui­vo existe;
  • con­ferir cam­in­hos de ima­gens;
  • evi­tar acen­tos e espaços em nomes de assets;
  • remover arquiv­os que­bra­dos;
  • recon­stru­ir o pro­je­to;
  • abrir o MGCB Edi­tor e ver­i­ficar refer­ên­cias.

5. Imagem não carrega

Se futu­ra­mente você ten­tar car­regar:

Content.Load<Texture2D>("player");

mas o arqui­vo estiv­er em:

Content/sprites/player.png

o cor­re­to será provavel­mente:

Content.Load<Texture2D>("sprites/player");

Sem exten­são.

Esse detal­he causa muitos erros em ini­ciantes.

📦 Organização de assets: regra de ouro

Use nomes sim­ples.

Evite:

Meu Personagem Final Versão 2.png

Pre­fi­ra:

player.png
enemy_slime.png
coin_gold.png
background_forest.png

Boas práti­cas:

✅ letras minús­cu­las;
✅ sem acen­tos;
✅ sem espaços;
✅ nomes des­critivos;
✅ pas­tas por cat­e­go­ria;
✅ padroniza­ção des­de cedo.

Isso facili­ta muito o uso com Con­tent Pipeline e códi­go.

🎮 Primeira meta prática do capítulo

Até aqui, você deve con­seguir:

  1. insta­lar .NET;
  2. insta­lar edi­tor;
  3. insta­lar tem­plates;
  4. cri­ar pro­je­to Desk­topGL;
  5. rodar o jogo;
  6. mudar títu­lo da janela;
  7. mudar res­olução;
  8. enten­der arquiv­os prin­ci­pais.

Esse é o pon­to de par­ti­da real.

Não avance para sprites, col­isão ou input se o ambi­ente ain­da estiv­er instáv­el.

Um pro­je­to de jogo pre­cisa de fun­dação.

🧠 Mentalidade correta para configurar MonoGame

Mui­ta gente quer pular dire­to para o per­son­agem andan­do na tela.

Mas a preparação do ambi­ente ensi­na uma habil­i­dade profis­sion­al: con­t­role do fluxo de desen­volvi­men­to.

Você aprende a lidar com:

  • ter­mi­nal;
  • SDK;
  • dependên­cias;
  • com­pi­lação;
  • estru­tu­ra de pro­je­to;
  • assets;
  • erros;
  • orga­ni­za­ção.

Isso parece menos diver­tido do que desen­har sprites, mas é essen­cial.

Um desen­volve­dor de jogos não ape­nas cria mecâni­cas. Ele man­tém um pro­je­to vivo, orga­ni­za­do e exe­cutáv­el.

🧭 Fluxo recomendado para trabalhar com MonoGame

Use este fluxo no dia a dia:

1. Abrir o editor
2. Abrir terminal na pasta do projeto
3. Rodar dotnet build
4. Rodar dotnet run
5. Fazer pequena alteração
6. Testar novamente
7. Salvar no Git
8. Repetir

Coman­do para com­pi­lar sem rodar:

dotnet build

Coman­do para rodar:

dotnet run

Coman­do para limpar build:

dotnet clean

Coman­do para restau­rar pacotes:

dotnet restore

Ess­es coman­dos serão seus com­pan­heiros durante todo o cur­so.

🧩 Preparando o ambiente para os próximos capítulos

Depois de con­fig­u­rar tudo, crie uma pas­ta de estu­dos:

MonoGameCurso/
├── Capitulo02_Ambiente/
├── Capitulo03_GameLoop/
├── Capitulo04_Sprites/
├── Capitulo05_Input/
├── Capitulo06_Colisao/
└── ProjetoFinal/

Isso aju­da a sep­a­rar exper­i­men­tos de pro­je­to final.

Você pode ter um pro­je­to por capí­tu­lo ou um pro­je­to úni­co evoluin­do aos poucos.

Para cur­so, recomen­do:

um pro­je­to por capí­tu­lo + um pro­je­to final con­sol­i­da­do.

Assim você con­segue voltar e estu­dar cada eta­pa sep­a­rada­mente.

🧱 Projeto base sugerido

Nome do pro­je­to:

MonoGameCursoBase

Coman­do:

dotnet new mgdesktopgl -o MonoGameCursoBase

Depois:

cd MonoGameCursoBase
dotnet run

Altere a janela:

public Game1()
{
    _graphics = new GraphicsDeviceManager(this);
    Content.RootDirectory = "Content";
    IsMouseVisible = true;

    Window.Title = "MonoGame Curso Completo";

    _graphics.PreferredBackBufferWidth = 1280;
    _graphics.PreferredBackBufferHeight = 720;
    _graphics.ApplyChanges();
}

Esse será seu pon­to de par­ti­da.

✅ Checklist final do Capítulo 2

Antes de ir para o próx­i­mo capí­tu­lo, con­firme:

✅ Instalei o .NET SDK;
✅ Ver­i­fiquei com dotnet --version;
✅ Escol­hi Visu­al Stu­dio, VS Code ou Rid­er;
✅ Instalei os tem­plates do MonoGame;
✅ Criei um pro­je­to Desk­topGL;
✅ Rodei o pro­je­to com dotnet run;
✅ Enten­di o papel de Program.cs;
✅ Enten­di o papel de Game1.cs;
✅ Iden­ti­fiquei Initialize, LoadContent, Update e Draw;
✅ Enten­di para que serve a pas­ta Content;
✅ Enten­di o papel do MGCB;
✅ Per­son­al­izei títu­lo e res­olução da janela;
✅ Criei uma estru­tu­ra ini­cial de orga­ni­za­ção;
✅ Sei resolver erros bási­cos de insta­lação.

Se você mar­cou tudo, está pron­to para o Capí­tu­lo 3.

🏁 Conclusão: ambiente pronto, jogo prestes a nascer

Preparar o ambi­ente de desen­volvi­men­to pode pare­cer uma eta­pa sim­ples, mas ela define a qual­i­dade da sua jor­na­da com MonoGame.

Quan­do o .NET está insta­l­a­do cor­re­ta­mente, os tem­plates fun­cionam, o pro­je­to abre, o edi­tor recon­hece C#, o Con­tent Pipeline está no lugar e a janela do jogo aparece, você deixou de estar ape­nas estu­dan­do teo­ria. Você tem uma base real para começar a con­stru­ir.

A par­tir daqui, o MonoGame deixa de ser ape­nas um con­ceito e se tor­na uma tela em bran­co.

No próx­i­mo capí­tu­lo, o foco será o coração de qual­quer jogo:

o game loop.

Você vai enten­der como Update e Draw tra­bal­ham jun­tos para trans­for­mar códi­go em movi­men­to, inter­ação e exper­iên­cia visu­al.

❓ FAQ — Preparando o ambiente MonoGame

1. Preciso instalar o .NET SDK ou só o Runtime?

Você pre­cisa insta­lar o .NET SDK. O Run­time ape­nas exe­cu­ta apli­cações; o SDK per­mite cri­ar, com­pi­lar e desen­volver pro­je­tos .NET.

2. Qual editor usar para MonoGame?

Visu­al Stu­dio é óti­mo no Win­dows. VS Code é leve e mul­ti­platafor­ma. Rid­er é exce­lente para quem já tra­bal­ha com .NET.

3. Qual template devo usar primeiro?

O mais recomen­da­do para começar é o Desk­topGL, porque per­mite cri­ar jogos para Win­dows, macOS e Lin­ux com a mes­ma base de códi­go.

4. Como instalo os templates do MonoGame?

Use:

dotnet new install MonoGame.Templates.CSharp

Esse é o coman­do indi­ca­do na doc­u­men­tação ofi­cial de con­fig­u­ração com VS Code.

5. Como crio meu primeiro projeto?

Use:

dotnet new mgdesktopgl -o MeuPrimeiroJogo

Depois:

cd MeuPrimeiroJogo
dotnet run

6. O que é o MGCB?

MGCB é o MonoGame Con­tent Builder, fer­ra­men­ta usa­da para proces­sar con­teú­do como ima­gens, sons e fontes para uso em pro­je­tos MonoGame.

7. Preciso aprender terminal?

Sim, pelo menos o bási­co. Coman­dos como dotnet run, dotnet build e dotnet restore fazem parte do fluxo.

8. Posso usar MonoGame no Linux ou macOS?

Sim. O Desk­topGL é uma platafor­ma pen­sa­da para rodar em Win­dows, macOS e Lin­ux com a mes­ma base de códi­go.

9. Preciso saber C# antes?

Aju­da muito. Mas você pode apren­der C# jun­to com MonoGame, des­de que comece com pro­je­tos pequenos.

10. Posso começar criando um jogo grande?

Não é recomen­da­do. Comece com pro­je­tos pequenos como Pong, Snake, Break­out ou um jogo sim­ples de cole­tar moedas.

Capí­tu­lo 1 — O que é MonoGame e por que usar para cri­ar jogos

Capí­tu­lo 2 — Preparan­do o Ambi­ente de Desen­volvi­men­to

Capí­tu­lo 3 — Fun­da­men­tos do Game Loop: Update e Draw

Capí­tu­lo 4 — Sprites, Tex­turas e Con­tent Pipeline

Capí­tu­lo 5 — Entra­da do Jogador: Tecla­do, Mouse e Con­t­role

Capí­tu­lo 6 — Col­isão, Físi­ca Sim­ples e Movi­men­tação

Capí­tu­lo 7 — Cenas, Menus e Arquite­tu­ra do Jogo

Capí­tu­lo 8 — Áudio, Partícu­las, Ani­mações e Poli­men­to

Capí­tu­lo 9 — Shaders, Câmera, Mapas e Per­for­mance

Capí­tu­lo 10 — Pub­li­cação, Mon­e­ti­za­ção e Pro­je­to Final no MonoGame

Posts Similares