morpheus/ATV_26_11_RicardoBlack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Aula Ricardo

Browse Source
This commit is contained in:
morpheus_nox
2025-11-26 23:15:53 -03:00
commit 9d78ac4cc6
24 changed files with 1915 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

690
README.md Normal file
View File

@@ -0,0 +1,690 @@
# Jogo **Blackjack (21)**
Vamos construir um **Blackjack (21)** profissional, com arquitetura MVC (Model-View-Controller).
---
### 🏗️ 1. Preparação do Ambiente e Estrutura
Você precisará do **JDK 21** instalado e de uma IDE (IntelliJ IDEA ou Eclipse). Vamos usar o **Maven** para gerenciar as dependências.
**Estrutura de Pastas Recomendada:**
```text
blackjack21/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── blackjack/
│ │ │ ├── Main.java (Entrada)
│ │ │ ├── model/ (Lógica: Carta, Baralho, Mão)
│ │ │ └── controller/ (Interface e Regras de Jogo)
│ │ └── resources/
│ │ └── styles.css (Estilo Moderno)
└── pom.xml
```
**Dependências no `pom.xml`:**
Precisamos das bibliotecas do JavaFX.
```xml
<dependencies>
<dependency>
<groupId>org.openjfx</groupId>
<artifactId>javafx-controls</artifactId>
<version>21</version>
</dependency>
<dependency>
<groupId>org.openjfx</groupId>
<artifactId>javafx-fxml</artifactId>
<version>21</version>
</dependency>
</dependencies>
```
---
### 🚀 2. Configuração e Execução no Windows
#### Pré-requisitos
- **JDK 21** instalado
- **Maven** instalado globalmente (ou use o Maven Wrapper incluído)
#### Problema Comum: Maven Wrapper
Se você encontrar o erro:
```
Get-Content : Cannot find path '.mvn\wrapper\maven-wrapper.properties' because it does not exist.
```
**Solução:**
1. Abra o PowerShell no diretório do projeto
2. Execute o comando para regenerar o Maven Wrapper:
```powershell
mvn -N wrapper:wrapper
```
#### Como Executar o Projeto
```powershell
# Navegar para o diretório do projeto
cd "caminho\para\jogo_blackjack_21_fx"
# Executar a aplicação JavaFX
.\mvnw javafx:run
# Ou limpar e executar
.\mvnw clean javafx:run
```
#### Outros Comandos Úteis
```powershell
# Apenas compilar
.\mvnw compile
# Limpar arquivos compilados
.\mvnw clean
# Executar testes (se houver)
.\mvnw test
```
---
### 🃏 4. O Modelo (Model)
Aqui ficam as regras de negócio, independentes da interface visual.
**Classe `Carta.java` e Enums:**
```java
package com.blackjack.model;
public record Carta(Nipe nipe, Rank rank) {
public enum Nipe { COPAS, OUROS, PAUS, ESPADAS }
public enum Rank {
DOIS(2), TRES(3), QUATRO(4), CINCO(5), SEIS(6), SETE(7), OITO(8), NOVE(9), DEZ(10),
VALETE(10), DAMA(10), REI(10), AS(11);
final int valor;
Rank(int valor) { this.valor = valor; }
}
@Override
public String toString() {
return rank + " de " + nipe;
}
}
```
**Classe `Baralho.java`:**
```java
package com.blackjack.model;
import java.util.*;
public class Baralho {
private final Stack<Carta> cartas = new Stack<>();
public Baralho() {
reiniciar();
}
public void reiniciar() {
cartas.clear();
for (Carta.Nipe nipe : Carta.Nipe.values()) {
for (Carta.Rank rank : Carta.Rank.values()) {
cartas.push(new Carta(nipe, rank));
}
}
Collections.shuffle(cartas);
}
public Carta comprar() {
return cartas.isEmpty() ? null : cartas.pop();
}
}
```
---
### 🧠 5. Lógica de Pontuação (Regra do Ás)
O Ás é "tricky". Ele vale 11, a menos que estoure 21, aí passa a valer 1.
**Classe `Mao.java`:**
```java
package com.blackjack.model;
import java.util.ArrayList;
import java.util.List;
public class Mao {
private final List<Carta> cartas = new ArrayList<>();
public void adicionarCarta(Carta carta) {
cartas.add(carta);
}
public void limpar() {
cartas.clear();
}
public List<Carta> getCartas() {
return cartas;
}
public int calcularPontuacao() {
int pontos = 0;
int ases = 0;
for (Carta c : cartas) {
pontos += c.rank().valor;
if (c.rank() == Carta.Rank.AS) ases++;
}
while (pontos > 21 && ases > 0) {
pontos -= 10; // Transforma Ás de 11 para 1
ases--;
}
return pontos;
}
}
```
---
### 🎨 6. Interface Moderna e Controle (View & Controller)
Em vez de usar HTML/DOM (que é Web), usaremos o **Scenegraph** do JavaFX. Para ser didático, farei a interface via código para você ver a estrutura, mas em projetos grandes usamos arquivos FXML.
**Classe `BlackjackGame.java` (O Coração da UI):**
```java
package com.blackjack.controller;
import com.blackjack.model.*;
import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.Stage;
public class BlackjackGame extends Application {
private Baralho baralho;
private Mao maoJogador;
private Mao maoDealer;
private HBox mesaDealer;
private HBox mesaJogador;
private Label lblStatus;
private Label lblPontosJogador;
private Button btnPedir;
private Button btnParar;
private Button btnReiniciar;
@Override
public void start(Stage stage) {
baralho = new Baralho();
maoJogador = new Mao();
maoDealer = new Mao();
// --- Layout da Interface (Responsiva) ---
VBox root = new VBox(20);
root.setAlignment(Pos.CENTER);
root.setStyle("-fx-background-color: #2E8B57; -fx-padding: 30;"); // Verde Mesa de Jogo
// Área do Dealer
Label lblDealer = new Label("Dealer");
lblDealer.getStyleClass().add("titulo");
mesaDealer = new HBox(10);
mesaDealer.setAlignment(Pos.CENTER);
// Área do Jogador
Label lblJogador = new Label("Você");
lblJogador.getStyleClass().add("titulo");
mesaJogador = new HBox(10);
mesaJogador.setAlignment(Pos.CENTER);
lblPontosJogador = new Label("Pontos: 0");
lblPontosJogador.getStyleClass().add("texto-branco");
// Botões
HBox painelBotoes = new HBox(15);
painelBotoes.setAlignment(Pos.CENTER);
btnPedir = criarBotao("Pedir Carta", "#3498db");
btnParar = criarBotao("Parar", "#e74c3c");
btnReiniciar = criarBotao("Novo Jogo", "#f1c40f");
btnReiniciar.setVisible(false); // Só aparece no fim
painelBotoes.getChildren().addAll(btnPedir, btnParar, btnReiniciar);
lblStatus = new Label("Bem-vindo ao Blackjack!");
lblStatus.getStyleClass().add("status");
root.getChildren().addAll(lblDealer, mesaDealer, lblStatus, mesaJogador, lblJogador, lblPontosJogador, painelBotoes);
// --- Eventos (Interatividade) ---
btnPedir.setOnAction(e -> comprarCartaJogador());
btnParar.setOnAction(e -> turnoDealer());
btnReiniciar.setOnAction(e -> iniciarJogo());
Scene scene = new Scene(root, 800, 600);
scene.getStylesheets().add(getClass().getResource("/styles.css").toExternalForm());
stage.setTitle("Blackjack Java 21");
stage.setScene(scene);
stage.show();
iniciarJogo();
}
private void iniciarJogo() {
baralho.reiniciar();
maoJogador.limpar();
maoDealer.limpar();
btnPedir.setDisable(false);
btnParar.setDisable(false);
btnReiniciar.setVisible(false);
lblStatus.setText("Sua vez...");
// Distribuição inicial
maoJogador.adicionarCarta(baralho.comprar());
maoDealer.adicionarCarta(baralho.comprar());
maoJogador.adicionarCarta(baralho.comprar());
maoDealer.adicionarCarta(baralho.comprar());
atualizarMesa(false);
}
private void comprarCartaJogador() {
maoJogador.adicionarCarta(baralho.comprar());
if (maoJogador.calcularPontuacao() > 21) {
atualizarMesa(false);
fimDeJogo("Você estourou! Dealer venceu.");
} else {
atualizarMesa(false);
}
}
private void turnoDealer() {
// Dealer compra até ter 17 ou mais
while (maoDealer.calcularPontuacao() < 17) {
maoDealer.adicionarCarta(baralho.comprar());
}
verificarVencedor();
}
private void verificarVencedor() {
int pJogador = maoJogador.calcularPontuacao();
int pDealer = maoDealer.calcularPontuacao();
atualizarMesa(true); // Revela cartas do dealer
if (pDealer > 21) {
fimDeJogo("Dealer estourou! Você venceu!");
} else if (pJogador > pDealer) {
fimDeJogo("Você venceu!");
} else if (pJogador < pDealer) {
fimDeJogo("Dealer venceu.");
} else {
fimDeJogo("Empate.");
}
}
private void fimDeJogo(String mensagem) {
lblStatus.setText(mensagem);
btnPedir.setDisable(true);
btnParar.setDisable(true);
btnReiniciar.setVisible(true);
}
// Atualiza a "DOM" do JavaFX
private void atualizarMesa(boolean mostrarTudoDealer) {
mesaJogador.getChildren().clear();
mesaDealer.getChildren().clear();
// Renderiza Jogador
for (Carta c : maoJogador.getCartas()) {
mesaJogador.getChildren().add(criarVisualCarta(c));
}
lblPontosJogador.setText("Pontos: " + maoJogador.calcularPontuacao());
// Renderiza Dealer
List<Carta> cartasDealer = maoDealer.getCartas();
for (int i = 0; i < cartasDealer.size(); i++) {
if (i == 0 && !mostrarTudoDealer) {
// Carta oculta
mesaDealer.getChildren().add(criarVisualCartaOculta());
} else {
mesaDealer.getChildren().add(criarVisualCarta(cartasDealer.get(i)));
}
}
}
// Helpers de UI
private StackPane criarVisualCarta(Carta c) {
StackPane card = new StackPane();
card.setPrefSize(80, 120);
card.getStyleClass().add("carta");
Label lbl = new Label(c.toString());
lbl.setWrapText(true);
card.getChildren().add(lbl);
return card;
}
private StackPane criarVisualCartaOculta() {
StackPane card = new StackPane();
card.setPrefSize(80, 120);
card.getStyleClass().add("carta-oculta");
return card;
}
private Button criarBotao(String texto, String cor) {
Button btn = new Button(texto);
btn.setStyle("-fx-background-color: " + cor + "; -fx-text-fill: white; -fx-font-weight: bold; -fx-font-size: 14px;");
btn.setPrefWidth(120);
return btn;
}
public static void main(String[] args) {
launch();
}
}
```
---
### 💅 5. Estilização CSS (Moderno e Responsivo)
Salve como `src/main/resources/styles.css`. Isso substitui a necessidade de HTML.
```css
.root {
-fx-font-family: "Segoe UI", sans-serif;
}
.titulo {
-fx-font-size: 24px;
-fx-text-fill: white;
-fx-font-weight: bold;
-fx-effect: dropshadow(three-pass-box, rgba(0, 0, 0, 0.6), 5, 0, 0, 1);
}
.texto-branco {
-fx-text-fill: white;
-fx-font-size: 18px;
}
.status {
-fx-font-size: 28px;
-fx-text-fill: #f1c40f;
-fx-font-weight: bold;
-fx-effect: dropshadow(three-pass-box, rgba(0, 0, 0, 0.8), 10, 0, 0, 0);
}
.carta {
-fx-background-color: white;
-fx-background-radius: 10;
-fx-border-color: #333;
-fx-border-radius: 10;
-fx-border-width: 2;
-fx-effect: dropshadow(three-pass-box, rgba(0, 0, 0, 0.4), 10, 0, 5, 5);
}
.carta-oculta {
-fx-background-color: #a93226; /* Vermelho fundo carta */
-fx-background-radius: 10;
-fx-border-color: white;
-fx-border-width: 3;
-fx-border-style: dashed;
}
```
---
### 🚀 8. Gerar Versão Desktop (Java FX)
No Java moderno, não usamos Electron. Usamos **jpackage** (incluso no JDK 21) para criar um `.exe` ou `.msi` nativo.
1. **Compile o projeto** (via Maven):
`mvn clean package`
2. **Gere a imagem nativa** (Exemplo de comando simplificado):
```bash
jpackage --input target/ --name Blackjack21 --main-jar blackjack-1.0.jar --main-class com.blackjack.controller.BlackjackGame --type app-image
```
Isso criará um executável que o usuário pode clicar e jogar sem precisar instalar o Java manualmente.
---
### Próximo Passo
### 🚀 9. Refatoração
Esse erro é um clássico no desenvolvimento moderno com JavaFX (pós-JDK 11).
O motivo: Desde o Java 11, o JavaFX foi removido do JDK padrão e agora vive como módulos separados. Quando você tenta rodar diretamente uma classe que estende `Application` (como a nossa `BlackjackApp`), a JVM tenta carregar os componentes gráficos nativos antes mesmo de olhar para o seu classpath, e falha.
Vou te ensinar o **padrão da indústria** para resolver isso sem precisar ficar configurando argumentos complexos de VM (`--module-path`, etc). Usaremos a técnica do **Launcher (Lançador)**.
Siga estes passos simples:
### ✅ A Solução: O "Truque" do Launcher
Precisamos criar uma classe simples que **não** estenda `Application`, apenas para chamar o `main` da classe principal. Isso engana a JVM e permite que as bibliotecas sejam carregadas corretamente do classpath.
#### 1\. Crie a classe `Launcher.java`
Crie este arquivo na mesma pasta do seu `BlackjackApp.java` (`src/main/java/com/blackjack/Launcher.java`):
```java
package com.blackjack;
public class Launcher {
public static void main(String[] args) {
BlackjackApp.main(args);
}
}
```
#### 2\. Execute pelo Launcher
Agora, em vez de tentar rodar o `BlackjackApp.java`, **execute o `Launcher.java`**.
- **Se estiver no VS Code/IntelliJ:** Clique com o botão direito em `Launcher.java` e selecione "Run".
- **Se estiver via Linha de Comando:** Aponte para essa classe.
---
### 💡 Alternativa: Rodando via Maven (Recomendado)
Se você já configurou o `pom.xml` que te passei anteriormente, você nem precisa criar o Launcher se rodar direto pelo Maven. O plugin do JavaFX cuida disso para você.
Abra o terminal na pasta do projeto (onde está o `pom.xml`) e digite:
```bash
mvn clean javafx:run
```
Isso deve abrir a janela do jogo imediatamente.
### Resumo Técnico (Para seu aprendizado)
O erro acontece porque a classe `BlackjackApp` herda de `javafx.application.Application`. A JVM verifica isso na inicialização e exige que os módulos JavaFX estejam no _Module Path_. Ao usar a classe `Launcher` (que é uma classe Java comum), a aplicação inicia normalmente e, quando chama `BlackjackApp.main()`, as bibliotecas já estão carregadas no _Class Path_, contornando a verificação estrita da inicialização.
---
# Códigos Completos
**Dependências no `pom.xml`:**
Precisamos das bibliotecas do JavaFX.
```xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.blackjack</groupId>
<artifactId>blackjack-desktop</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<javafx.version>21</javafx.version>
</properties>
<dependencies>
<dependency>
<groupId>org.openjfx</groupId>
<artifactId>javafx-controls</artifactId>
<version>${javafx.version}</version>
</dependency>
<dependency>
<groupId>org.openjfx</groupId>
<artifactId>javafx-fxml</artifactId>
<version>${javafx.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
</plugin>
<plugin>
<groupId>org.openjfx</groupId>
<artifactId>javafx-maven-plugin</artifactId>
<version>0.0.8</version>
<configuration>
<mainClass>com.blackjack.BlackjackApp</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
```
---
### 💅 5. Estilização CSS (Moderno e Responsivo)
Salve como `src/main/resources/styles.css`. Isso substitui a necessidade de HTML.
```css
.root {
-fx-background-color: #0a5c0a; /* Verde clássico */
-fx-font-family: "Arial";
}
/* Títulos */
.titulo-principal {
-fx-text-fill: white;
-fx-font-size: 32px;
-fx-font-weight: bold;
-fx-padding: 20;
-fx-effect: dropshadow(three-pass-box, rgba(0, 0, 0, 0.5), 5, 0, 0, 1);
}
.titulo-area {
-fx-text-fill: #ffc107; /* Dourado */
-fx-font-size: 18px;
-fx-font-weight: bold;
}
/* Container das Mãos (Areas) */
.area-jogo {
-fx-background-color: rgba(0, 0, 0, 0.2);
-fx-border-color: #ffc107;
-fx-border-width: 2;
-fx-border-radius: 10;
-fx-background-radius: 10;
-fx-padding: 20;
-fx-spacing: 15;
-fx-alignment: center;
-fx-min-width: 600;
}
/* A Carta Visual */
.carta {
-fx-background-color: white;
-fx-background-radius: 8;
-fx-border-color: #333;
-fx-border-radius: 8;
-fx-border-width: 1;
-fx-pref-width: 80;
-fx-pref-height: 120;
-fx-effect: dropshadow(three-pass-box, rgba(0, 0, 0, 0.4), 8, 0, 2, 2);
}
.carta-texto {
-fx-font-size: 18px;
-fx-font-weight: bold;
}
.carta-naipe-grande {
-fx-font-size: 36px;
}
.red {
-fx-text-fill: #d90000;
}
.black {
-fx-text-fill: black;
}
/* Carta Oculta (Verso) */
.carta-oculta {
-fx-background-color: linear-gradient(to bottom right, #444, #666);
-fx-background-radius: 8;
-fx-border-color: white;
-fx-border-width: 2;
-fx-border-style: solid;
}
/* Mensagem de Status */
.status-msg {
-fx-text-fill: white;
-fx-font-size: 24px;
-fx-font-weight: bold;
-fx-padding: 10;
}
/* Botões */
.button {
-fx-background-color: #ffc107;
-fx-text-fill: #333;
-fx-font-size: 14px;
-fx-font-weight: bold;
-fx-background-radius: 5;
-fx-cursor: hand;
-fx-padding: 10 20;
}
.button:hover {
-fx-background-color: #ffd54f;
}
.button:disabled {
-fx-background-color: #999;
-fx-opacity: 0.7;
}
```
---
### [ricardotecpro.github.io](https://ricardotecpro.github.io/)