691 lines
18 KiB
Markdown
691 lines
18 KiB
Markdown
# 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/)
|