🎯 Objetivos da Aula
Random
Números aleatórios
Lógica
Regras do jogo
Loop
Repetir até acertar
Projeto
Jogo de adivinhação
📚 Conteúdo da Aula
🎮 Introdução ao Mundo dos Jogos
Por que Criar Jogos?
Programar jogos é uma das formas mais divertidas de aprender! É como ser um mágico que cria mundos digitais!
🌟 Benefícios de Programar Jogos:
Raciocínio Lógico
Pensar em regras e estratégias
Criatividade
Inventar histórias e mecânicas
Resolução de Problemas
Encontrar soluções para bugs
Projeto Completo
Do início ao fim do programa
🎲 Tipos de Jogos que Vamos Aprender:
Adivinhação
Descobrir o número secreto
Pedra, Papel, Tesoura
Clássico jogo de estratégia
Quiz Interativo
Perguntas e respostas
Jogo da Sorte
Elementos aleatórios
💡 Conceito-chave: Todo jogo precisa de regras claras, desafios interessantes e uma forma de vencer!
🎲 Descobrindo o Módulo Random
A Magia dos Números Aleatórios
Para criar jogos emocionantes, precisamos de imprevisibilidade! É aí que entra o módulo random!
🤔 O que é "Random"?
Analogia do Dado:
Imagine um dado super especial que pode ter qualquer quantidade de lados! O módulo random é como esse dado mágico!
🔧 Funções Principais do Random:
🔢 random.randint(a, b)
Gera um número inteiro aleatório entre 'a' e 'b' (incluindo ambos)
random.randint(1, 10) # Pode dar: 1, 2, 3, ..., 10
🎯 random.choice(lista)
Escolhe um item aleatório de uma lista
random.choice(['A', 'B', 'C']) # Pode dar: 'A', 'B' ou 'C'
🔀 random.shuffle(lista)
Embaralha os itens de uma lista
cartas = [1, 2, 3, 4]
random.shuffle(cartas) # Embaralha a ordem
🧪 Testando o Random:
# Importando o módulo random
import random
print("🎲 TESTANDO NÚMEROS ALEATÓRIOS 🎲")
print("="*40)
# Testando randint
print("🔢 Números de 1 a 10:")
for i in range(5):
numero = random.randint(1, 10)
print(f" Teste {i+1}: {numero}")
print("\n🎯 Escolhendo da lista:")
cores = ["vermelho", "azul", "verde", "amarelo", "roxo"]
for i in range(3):
cor_escolhida = random.choice(cores)
print(f" Cor {i+1}: {cor_escolhida}")
print("\n🔀 Embaralhando números:")
numeros = [1, 2, 3, 4, 5]
print(f"Original: {numeros}")
random.shuffle(numeros)
print(f"Embaralhado: {numeros}")
print("\n🎰 Simulando moeda:")
for i in range(5):
resultado = random.choice(["Cara", "Coroa"])
print(f" Lançamento {i+1}: {resultado}")💡 Dica Importante:
O import random deve estar sempre no início do programa! É como pedir permissão para usar a magia aleatória!
🏗️ Estrutura de um Jogo
Os Ingredientes de Todo Jogo
Assim como uma receita, todo jogo tem ingredientes essenciais!
🧩 Componentes Essenciais:
1
🎬 Introdução
Apresentar o jogo e suas regras
print("🎮 Bem-vindo ao jogo!")
⬇️
2
⚙️ Configuração
Definir variáveis iniciais
pontos = 0
vidas = 3
⬇️
3
🔄 Loop Principal
O coração do jogo
while jogando:
# Lógica do jogo aqui
⬇️
4
🏁 Finalização
Mostrar resultado final
print("🏆 Fim de jogo!")
🎯 Padrões Comuns em Jogos:
🔄 Loop de Repetição
Continuar até condição de vitória/derrota
🎯 Validação de Entrada
Verificar se a jogada é válida
🏆 Condições de Vitória
Quando o jogador ganha
💔 Condições de Derrota
Quando o jogo termina
🏗️ Template Básico de Jogo:
# Template para criar qualquer jogo
import random
def meu_jogo():
# 1. INTRODUÇÃO
print("🎮 BEM-VINDO AO MEU JOGO! 🎮")
print("="*30)
print("📖 Regras: [Explique as regras aqui]")
print()
# 2. CONFIGURAÇÃO INICIAL
pontos = 0
tentativas = 0
jogando = True
# 3. LOOP PRINCIPAL
while jogando:
print(f"🎯 Pontos: {pontos} | Tentativas: {tentativas}")
# Obter entrada do jogador
jogada = input("Sua jogada: ")
tentativas += 1
# Processar jogada
# [Sua lógica aqui]
# Verificar condições de fim
# if [condição de vitória]:
# print("🏆 Você ganhou!")
# jogando = False
# elif [condição de derrota]:
# print("💔 Você perdeu!")
# jogando = False
# 4. FINALIZAÇÃO
print(f"\n🎊 FIM DE JOGO! 🎊")
print(f"📊 Estatísticas finais:")
print(f" Pontos: {pontos}")
print(f" Tentativas: {tentativas}")
# Iniciar o jogo
if __name__ == "__main__":
meu_jogo()🔢 Projeto Principal - Jogo de Adivinhação Completo
🚀 Vamos Criar um Jogo Profissional!
Agora vamos construir passo a passo um jogo de adivinhação com todos os recursos!
📈 Evolução do Projeto:
V1.0
Versão Básica
Apenas adivinhar o número
→
V2.0
Com Dicas
Dizer se é maior ou menor
→
V3.0
Com Níveis
Fácil, médio e difícil
→
V4.0
Completa
Pontuação, recordes, etc.
🎮 Código Completo - Versão Final:
# 🎮 JOGO DE ADIVINHAÇÃO SUPER COMPLETO 🎮
import random
def escolher_dificuldade():
"""Permite ao jogador escolher o nível de dificuldade"""
print("🎯 ESCOLHA A DIFICULDADE:")
print("1. 😊 Fácil (1-50, 10 tentativas)")
print("2. 😐 Médio (1-100, 7 tentativas)")
print("3. 😰 Difícil (1-200, 5 tentativas)")
print("4. 😈 Extremo (1-500, 3 tentativas)")
while True:
try:
escolha = int(input("Digite sua escolha (1-4): "))
if escolha == 1:
return 50, 10, "😊 Fácil"
elif escolha == 2:
return 100, 7, "😐 Médio"
elif escolha == 3:
return 200, 5, "😰 Difícil"
elif escolha == 4:
return 500, 3, "😈 Extremo"
else:
print("❌ Escolha apenas 1, 2, 3 ou 4!")
except ValueError:
print("❌ Digite apenas números!")
def dar_dica(palpite, numero_secreto, tentativas_restantes):
"""Fornece dicas inteligentes baseadas na proximidade"""
diferenca = abs(palpite - numero_secreto)
if diferenca == 0:
return "🎉 ACERTOU! PARABÉNS!"
elif diferenca <= 5:
return "🔥 MUITO QUENTE! Está quase lá!"
elif diferenca <= 10:
return "♨️ Quente! Muito próximo!"
elif diferenca <= 20:
return "🌡️ Morno... chegando perto!"
elif diferenca <= 50:
return "❄️ Frio... ainda longe..."
else:
return "🧊 MUITO FRIO! Bem longe!"
def calcular_pontuacao(tentativas_usadas, max_tentativas, dificuldade_pontos):
"""Calcula pontuação baseada na performance"""
# Pontuação base pela dificuldade
pontos_base = dificuldade_pontos
# Bônus por eficiência (menos tentativas = mais pontos)
bonus_eficiencia = (max_tentativas - tentativas_usadas) * 10
# Pontuação final
pontuacao_final = pontos_base + bonus_eficiencia
return max(pontuacao_final, 0) # Nunca negativo
def jogo_adivinhacao():
"""Função principal do jogo de adivinhação"""
print("🎮" + "="*50 + "🎮")
print(" 🔢 JOGO DE ADIVINHAÇÃO SUPER COMPLETO 🔢")
print("🎮" + "="*50 + "🎮")
# Escolher dificuldade
max_numero, max_tentativas, nome_dificuldade = escolher_dificuldade()
# Gerar número secreto
numero_secreto = random.randint(1, max_numero)
# Configuração do jogo
tentativas_usadas = 0
pontos_dificuldade = {50: 100, 100: 200, 200: 400, 500: 800}
print(f"\n🎯 DIFICULDADE: {nome_dificuldade}")
print(f"🔢 Adivinhe o número entre 1 e {max_numero}")
print(f"💪 Você tem {max_tentativas} tentativas")
print(f"💡 Use as dicas de temperatura para se aproximar!")
print("-" * 60)
# Loop principal do jogo
while tentativas_usadas < max_tentativas:
tentativas_restantes = max_tentativas - tentativas_usadas
print(f"\n🎯 Tentativa {tentativas_usadas + 1}/{max_tentativas}")
print(f"⏰ Restam {tentativas_restantes} tentativas")
try:
palpite = int(input("🤔 Qual é seu palpite? "))
# Validar entrada
if palpite < 1 or palpite > max_numero:
print(f"❌ Digite apenas números entre 1 e {max_numero}!")
continue
tentativas_usadas += 1
# Verificar se acertou
if palpite == numero_secreto:
print("\n" + "🎉" * 20)
print("🏆 PARABÉNS! VOCÊ ACERTOU! 🏆")
print("🎉" * 20)
# Calcular pontuação
pontuacao = calcular_pontuacao(
tentativas_usadas,
max_tentativas,
pontos_dificuldade[max_numero]
)
print(f"\n📊 ESTATÍSTICAS DA PARTIDA:")
print(f" 🔢 Número secreto: {numero_secreto}")
print(f" 🎯 Tentativas usadas: {tentativas_usadas}/{max_tentativas}")
print(f" 🏆 Pontuação: {pontuacao} pontos")
print(f" ⭐ Eficiência: {((max_tentativas - tentativas_usadas) / max_tentativas * 100):.1f}%")
# Classificação de performance
if tentativas_usadas == 1:
print(" 🎊 INCRÍVEL! Acertou de primeira!")
elif tentativas_usadas <= max_tentativas // 3:
print(" 🌟 EXCELENTE! Muito eficiente!")
elif tentativas_usadas <= max_tentativas // 2:
print(" 👍 MUITO BOM! Boa estratégia!")
else:
print(" 😅 DEU CERTO! Foi por pouco!")
return True
# Dar dicas
dica_temperatura = dar_dica(palpite, numero_secreto, tentativas_restantes)
print(f"🌡️ {dica_temperatura}")
# Dica de direção
if palpite < numero_secreto:
print("📈 O número é MAIOR que seu palpite!")
else:
print("📉 O número é MENOR que seu palpite!")
except ValueError:
print("❌ Por favor, digite apenas números válidos!")
# Se chegou aqui, perdeu o jogo
print("\n" + "💔" * 20)
print("😢 GAME OVER! Suas tentativas acabaram!")
print("💔" * 20)
print(f"🔍 O número secreto era: {numero_secreto}")
print("🎮 Tente novamente para melhorar!")
return False
def menu_principal():
"""Menu principal com opções do jogo"""
vitorias = 0
derrotas = 0
while True:
print("\n🎮 MENU PRINCIPAL 🎮")
print("1. 🎯 Jogar")
print("2. 📊 Ver Estatísticas")
print("3. 📖 Como Jogar")
print("4. 🚪 Sair")
try:
opcao = int(input("Escolha uma opção: "))
if opcao == 1:
print("\n🚀 Iniciando novo jogo...")
if jogo_adivinhacao():
vitorias += 1
else:
derrotas += 1
elif opcao == 2:
print(f"\n📊 SUAS ESTATÍSTICAS:")
print(f" 🏆 Vitórias: {vitorias}")
print(f" 💔 Derrotas: {derrotas}")
total = vitorias + derrotas
if total > 0:
taxa_vitoria = (vitorias / total) * 100
print(f" 📈 Taxa de vitória: {taxa_vitoria:.1f}%")
else:
print(" 📝 Nenhum jogo jogado ainda!")
elif opcao == 3:
print(f"\n📖 COMO JOGAR:")
print("1. 🎯 Escolha a dificuldade")
print("2. 🤔 Tente adivinhar o número secreto")
print("3. 🌡️ Use as dicas de temperatura:")
print(" - 🧊 MUITO FRIO: Muito longe (diferença > 50)")
print(" - ❄️ FRIO: Longe (diferença 21-50)")
print(" - 🌡️ MORNO: Chegando perto (diferença 11-20)")
print(" - ♨️ QUENTE: Muito próximo (diferença 6-10)")
print(" - 🔥 MUITO QUENTE: Quase lá (diferença 1-5)")
print("4. 🏆 Ganhe pontos pela eficiência!")
elif opcao == 4:
print("👋 Obrigado por jogar! Até a próxima!")
break
else:
print("❌ Opção inválida! Escolha 1, 2, 3 ou 4.")
except ValueError:
print("❌ Digite apenas números!")
# Iniciar o programa
if __name__ == "__main__":
print("🎊 Bem-vindo ao melhor jogo de adivinhação! 🎊")
menu_principal()🌟 Recursos do Nosso Jogo:
4 níveis de dificuldade
Sistema de dicas inteligente
Sistema de pontuação
Estatísticas de performance
Validação de entradas
Menu interativo
💡 Conceitos Aplicados:
- Funções: Organização do código em blocos reutilizáveis
- Random: Geração de números aleatórios
- Loops: Repetição até condição de parada
- Condicionais: Lógica de decisão do jogo
- Tratamento de erro: try/except para entradas inválidas
✂️ Projeto Bônus - Pedra, Papel, Tesoura
🎮 Criando Outro Jogo Clássico!
Agora que dominamos os conceitos, vamos criar o famoso "Pedra, Papel, Tesoura"!
📖 Regras do Jogo:
Pedra vence Tesoura
✅
Papel vence Pedra
✅
Tesoura vence Papel
✅
🎮 Código do Jogo:
# 🎮 PEDRA, PAPEL, TESOURA SUPER COMPLETO 🎮
import random
def mostrar_opcoes():
"""Mostra as opções disponíveis"""
print("\n🎯 SUAS OPÇÕES:")
print("1. 🪨 Pedra")
print("2. 📄 Papel")
print("3. ✂️ Tesoura")
def obter_escolha_jogador():
"""Obtém e valida a escolha do jogador"""
opcoes = {1: "pedra", 2: "papel", 3: "tesoura"}
emojis = {"pedra": "🪨", "papel": "📄", "tesoura": "✂️"}
while True:
try:
escolha = int(input("Sua escolha (1-3): "))
if escolha in opcoes:
escolha_nome = opcoes[escolha]
emoji = emojis[escolha_nome]
return escolha_nome, emoji
else:
print("❌ Escolha apenas 1, 2 ou 3!")
except ValueError:
print("❌ Digite apenas números!")
def obter_escolha_computador():
"""Gera escolha aleatória do computador"""
opcoes = ["pedra", "papel", "tesoura"]
emojis = {"pedra": "🪨", "papel": "📄", "tesoura": "✂️"}
escolha = random.choice(opcoes)
emoji = emojis[escolha]
return escolha, emoji
def determinar_vencedor(jogador, computador):
"""Determina quem venceu a rodada"""
if jogador == computador:
return "empate"
# Condições de vitória do jogador
condicoes_vitoria = {
("pedra", "tesoura"),
("papel", "pedra"),
("tesoura", "papel")
}
if (jogador, computador) in condicoes_vitoria:
return "jogador"
else:
return "computador"
def mostrar_resultado_rodada(jogador_escolha, jogador_emoji, comp_escolha, comp_emoji, resultado):
"""Mostra o resultado visual da rodada"""
print("\n" + "⚔️" * 15 + " RESULTADO " + "⚔️" * 15)
print(f"👤 Você escolheu: {jogador_emoji} {jogador_escolha.upper()}")
print(f"🤖 Computador escolheu: {comp_emoji} {comp_escolha.upper()}")
print("-" * 50)
if resultado == "empate":
print("🤝 EMPATE! Vocês pensaram igual!")
elif resultado == "jogador":
print("🎉 VOCÊ VENCEU esta rodada!")
# Explicar por que venceu
explicacoes = {
("pedra", "tesoura"): "🪨 Pedra quebra Tesoura!",
("papel", "pedra"): "📄 Papel embrulha Pedra!",
("tesoura", "papel"): "✂️ Tesoura corta Papel!"
}
print(f"💡 {explicacoes[(jogador_escolha, comp_escolha)]}")
else:
print("😔 COMPUTADOR VENCEU esta rodada!")
# Explicar por que perdeu
explicacoes = {
("tesoura", "pedra"): "🪨 Pedra quebra Tesoura!",
("pedra", "papel"): "📄 Papel embrulha Pedra!",
("papel", "tesoura"): "✂️ Tesoura corta Papel!"
}
print(f"💡 {explicacoes[(comp_escolha, jogador_escolha)]}")
def jogo_pedra_papel_tesoura():
"""Função principal do jogo"""
print("🎮" + "="*60 + "🎮")
print(" ✂️ PEDRA, PAPEL, TESOURA - EDIÇÃO DELUXE ✂️")
print("🎮" + "="*60 + "🎮")
# Configurações do jogo
pontos_jogador = 0
pontos_computador = 0
empates = 0
rodada = 1
print("\n🎯 COMO JOGAR:")
print("🪨 Pedra quebra Tesoura")
print("📄 Papel embrulha Pedra")
print("✂️ Tesoura corta Papel")
print("\n🏆 Primeiro a ganhar 3 rodadas vence o jogo!")
# Loop principal do jogo
while pontos_jogador < 3 and pontos_computador < 3:
print(f"\n{'🔥' * 20} RODADA {rodada} {'🔥' * 20}")
print(f"📊 PLACAR: Você {pontos_jogador} x {pontos_computador} Computador (Empates: {empates})")
# Obter escolhas
mostrar_opcoes()
jogador_escolha, jogador_emoji = obter_escolha_jogador()
comp_escolha, comp_emoji = obter_escolha_computador()
# Determinar vencedor
resultado = determinar_vencedor(jogador_escolha, comp_escolha)
# Mostrar resultado
mostrar_resultado_rodada(jogador_escolha, jogador_emoji, comp_escolha, comp_emoji, resultado)
# Atualizar pontuação
if resultado == "jogador":
pontos_jogador += 1
elif resultado == "computador":
pontos_computador += 1
else:
empates += 1
rodada += 1
# Pausa dramática
input("\n⏸️ Pressione ENTER para continuar...")
# Resultado final
print("\n" + "🏆" * 25)
print(" 🎊 FIM DE JOGO! 🎊")
print("🏆" * 25)
print(f"\n📊 ESTATÍSTICAS FINAIS:")
print(f" 👤 Suas vitórias: {pontos_jogador}")
print(f" 🤖 Vitórias do computador: {pontos_computador}")
print(f" 🤝 Empates: {empates}")
print(f" 🎯 Total de rodadas: {rodada - 1}")
if pontos_jogador > pontos_computador:
print("\n🎉 PARABÉNS! VOCÊ É O CAMPEÃO! 🎉")
print("🌟 Sua estratégia foi superior!")
else:
print("\n🤖 O COMPUTADOR VENCEU! 🤖")
print("😅 Que tal uma revanche?")
# Oferecer nova partida
while True:
jogar_novamente = input("\n🔄 Quer jogar novamente? (s/n): ").lower()
if jogar_novamente in ['s', 'sim']:
return True
elif jogar_novamente in ['n', 'não', 'nao']:
return False
else:
print("❌ Digite 's' para sim ou 'n' para não")
# Menu principal
def menu_jogo():
"""Menu principal do jogo"""
jogos_jogados = 0
vitorias = 0
while True:
print("\n🎮 MENU PRINCIPAL - PEDRA, PAPEL, TESOURA 🎮")
print("1. 🎯 Jogar")
print("2. 📊 Estatísticas")
print("3. 📖 Regras")
print("4. 🚪 Sair")
try:
opcao = int(input("Escolha uma opção: "))
if opcao == 1:
if jogo_pedra_papel_tesoura():
jogos_jogados += 1
# Aqui você poderia adicionar lógica para contar vitórias
else:
break
elif opcao == 2:
print(f"\n📊 SUAS ESTATÍSTICAS:")
print(f" 🎮 Jogos jogados: {jogos_jogados}")
if jogos_jogados > 0:
print(" 💪 Continue jogando para mais estatísticas!")
else:
print(" 📝 Jogue algumas partidas para ver suas estatísticas!")
elif opcao == 3:
print(f"\n📖 REGRAS DETALHADAS:")
print("🎯 OBJETIVO: Seja o primeiro a ganhar 3 rodadas")
print("\n🔧 COMO FUNCIONA:")
print("1. Você e o computador escolhem ao mesmo tempo")
print("2. As escolhas são reveladas simultaneamente")
print("3. O vencedor é determinado pelas regras:")
print(" • 🪨 Pedra quebra ✂️ Tesoura")
print(" • 📄 Papel embrulha 🪨 Pedra")
print(" • ✂️ Tesoura corta 📄 Papel")
print(" • Escolhas iguais = Empate")
print("4. Primeiro a 3 vitórias ganha!")
elif opcao == 4:
print("👋 Obrigado por jogar! Até mais!")
break
else:
print("❌ Opção inválida! Escolha 1, 2, 3 ou 4.")
except ValueError:
print("❌ Digite apenas números!")
# Iniciar o programa
if __name__ == "__main__":
print("🎊 Bem-vindo ao melhor Pedra, Papel, Tesoura! 🎊")
menu_jogo()🆚 Comparando os Jogos:
Aspecto
🔢 Adivinhação
✂️ Pedra, Papel, Tesoura
Tipo
Solo vs Computador
Duelo vs Computador
Random
Número secreto
Escolha do computador
Estratégia
Dedução lógica
Psicologia e sorte
Fim
Acertar ou esgotar tentativas
Primeiro a 3 vitórias
🏠 Desafios para Casa
🎯 Desafio Principal: Quiz Interativo
Crie um jogo de perguntas e respostas sobre seus assuntos favoritos!
📋 Requisitos do Quiz:
- 🗂️ Pelo menos 10 perguntas sobre um tema
- 🔀 Perguntas em ordem aleatória
- 🏆 Sistema de pontuação
- ⏱️ Limite de tempo opcional
- 📊 Estatísticas finais
- 🎨 Interface colorida e divertida
🏗️ Estrutura Base do Quiz:
import random
import time
def criar_perguntas():
"""Cria o banco de perguntas"""
perguntas = [
{
"pergunta": "Qual é a capital do Brasil?",
"opcoes": ["A) São Paulo", "B) Rio de Janeiro", "C) Brasília", "D) Belo Horizonte"],
"resposta": "C",
"explicacao": "Brasília é a capital federal desde 1960!"
},
# Adicione mais perguntas aqui...
]
return perguntas
def fazer_pergunta(pergunta_dict, numero):
"""Faz uma pergunta e retorna se acertou"""
print(f"\n❓ PERGUNTA {numero}:")
print(pergunta_dict["pergunta"])
for opcao in pergunta_dict["opcoes"]:
print(f" {opcao}")
# Seu código aqui...
pass
def quiz_interativo():
"""Função principal do quiz"""
# Sua implementação aqui...
pass
# Testar o quiz
quiz_interativo()🎯 Desafios Bônus:
Caça-Níqueis Simples
3 roletas com símbolos, combinações dão prêmios
Jogo de Dados
Apostar no resultado de dois dados
Jogo da Forca
Adivinhar palavra letra por letra
Quebra-Cabeça Numérico
Ordenar sequência embaralhada
🎓 O que Você Vai Aprender:
Loops avançados e controle de fluxo
Estruturas de dados (listas e dicionários)
Validação robusta de entradas
Interface de usuário atrativa
Lógica de programação complexa