Jogo Tetris GG

-- Configurações do Tabuleiro Principal
local largura = 10
local altura = 20
ultimoBonus = 0

-- Inicializa o tabuleiro principal (matriz altura x largura)
local tabuleiro = {}
for y = 1, altura do
  tabuleiro[y] = {}
  for x = 1, largura do
    tabuleiro[y][x] = 0  -- 0: célula vazia
  end
end
-- Definição das Peças (cada peça é uma matriz 2D)
-- As peças normais são representadas com 1; a peça especial (última) é um bloco único
local pecas = {
  { {1,1,1,1} },           -- Linha
  { {1,1}, {1,1} },        -- Quadrado
  { {0,1,0}, {1,1,1} },     -- T
  { {1,0}, {1,0}, {1,1} },  -- L
  { {0,1}, {0,1}, {1,1} },  -- J
  { {1,1,0}, {0,1,1} },     -- Z
  { {0,1,1}, {1,1,0} },     -- S
  { {1} }                  -- Peça especial (um bloco único)
}

-- Função para girar uma peça (matriz) 90° no sentido horário
local function girarPeca(peca)
  local nova = {}
  local larguraPeca = #peca[1]
  local alturaPeca = #peca
  for x = 1, larguraPeca do
    nova[x] = {}
    for y = 1, alturaPeca do
      nova[x][y] = peca[alturaPeca - y + 1][x]
    end
  end
  return nova
end
-- Cria uma cópia do tabuleiro principal para exibição (não altera o estado real)
local function copiarTabuleiro()
  local copia = {}
  for y = 1, altura do
    copia[y] = {}
    for x = 1, largura do
      copia[y][x] = tabuleiro[y][x]
    end
  end
  return copia
end
--------------------------------------------------------------------------------
-- Função para gerar a string do mini-tabuleiro (4x4) com a próxima peça.
-- A peça é centralizada (se couber) dentro da área 4x4.
local function gerarMiniTabuleiro(peca)
  -- Inicializa uma matriz 4x4 com zeros
  local mini = {}
  for y = 1, 4 do
    mini[y] = {}
    for x = 1, 4 do
      mini[y][x] = 0
    end
  end
  local pAltura = #peca
  local pLargura = #peca[1]

  -- Calcula offsets para centralizar a peça no mini-tabuleiro 4x4
  local offsetX = math.floor((4 - pLargura) / 2)
  local offsetY = math.floor((4 - pAltura) / 2)

  -- Preenche o mini-tabuleiro com a peça centralizada
  for y = 1, pAltura do
    for x = 1, pLargura do
      if peca[y][x] == 1 then
        local mx = x + offsetX
        local my = y + offsetY
        if mx >= 1 and mx <= 4 and my >= 1 and my <= 4 then
          -- Para a peça especial, usamos o valor 3; para as demais, 1.
          mini[my][mx] = (pLargura == 1 and pAltura == 1) and 3 or 1
        end
      end
    end
  end

  -- Converte o mini-tabuleiro para string (usando os mesmos emojis)
  local s = ""
  for y = 1, 4 do
    for x = 1, 4 do
      if mini[y][x] == 0 then
        s = s .. "⬛"
      elseif mini[y][x] == 1 then
        s = s .. "⬜"
      elseif mini[y][x] == 3 then
        s = s .. "🟥"
      end
    end
    s = s .. "\n"
  end
  return s
end
--------------------------------------------------------------------------------
-- Variáveis globais de pontuação e bônus
local pontuacao = 0
local ultimoBonus = 0  -- Valor do bônus obtido na última jogada

-- Função para exibir o tabuleiro principal com a peça em movimento, a pontuação e o bônus.
-- A exibição incluirá, do lado direito, o mini-tabuleiro com a próxima peça.
local function exibirTabuleiro(peca, px, py, pontuacao, proximaPeca)

if not peca then
        gg.toast("Erro: Nenhuma peça foi carregada!")
        return
end

  local temp = copiarTabuleiro()

  -- Insere a peça atual na cópia do tabuleiro
  for y = 1, #peca do
    for x = 1, #peca[y] do
      if peca[y][x] == 1 then
        local tx = px + x - 1
        local ty = py + y - 1
        if ty >= 1 and ty <= altura and tx >= 1 and tx <= largura then
          -- Se for a peça especial (único bloco), usamos o valor 3 para diferenciá-la
          if (#peca == 1 and #peca[1] == 1) then
            temp[ty][tx] = 3
          else
            temp[ty][tx] = 1
          end
        end
      end
    end
  end

  -- Monta a string do cabeçalho: pontuação e bônus (sempre exibindo o bônus, mesmo que 0)
  local saida = "🏆 Pontuação: " .. pontuacao .. "\n"

 -- saida = saida .. "Bônus: " .. tostring(ultimoBonus) .. " pts\n"
saida = saida ..string.rep(" ", 50).. "🔜Próxima Peça:\n"

  -- Constrói o mini-tabuleiro da próxima peça
  local miniStr = gerarMiniTabuleiro(proximaPeca)
  local miniLinhas = {}
  for linha in miniStr:gmatch("[^\n]+") do
    table.insert(miniLinhas, linha)
  end

  -- Concatena o tabuleiro principal com o mini-tabuleiro
  for y = 1, altura do
    for x = 1, largura do
      if temp[y][x] == 0 then
        saida = saida .. "⬛"
      elseif temp[y][x] == 1 then
        saida = saida .. "⬜"
      elseif temp[y][x] == 2 then
        saida = saida .. "🟨"
      elseif temp[y][x] == 3 then
        saida = saida .. "🟥"
      end
    end
    if y <= 3 and miniLinhas[y] then
      saida = saida .. "    " .. miniLinhas[y]
    end
    saida = saida .. "\n"
  end
  return saida
end
--------------------------------------------------------------------------------
-- Função para verificar se uma peça pode ser colocada na posição (px, py)
-- Para peças normais, a célula deve estar vazia.
-- Para a peça especial, ela ignora obstruções enquanto se move.
local function podeColocarPeca(peca, px, py, isSpecial)
  for y = 1, #peca do
    for x = 1, #peca[y] do
      if peca[y][x] == 1 then
        local tx = px + x - 1
        local ty = py + y - 1
        if tx < 1 or tx > largura or ty < 1 or ty > altura then
          return false
        end
        if not isSpecial then
          if tabuleiro[ty][tx] ~= 0 then
            return false
          end
        end
      end
    end
  end
  return true
end
--------------------------------------------------------------------------------
-- Função para fixar uma peça no tabuleiro.
-- Peças normais são marcadas com 2; a peça especial com 3.
local function fixarPeca(peca, px, py, isSpecial)
  for y = 1, #peca do
    for x = 1, #peca[y] do
      if peca[y][x] == 1 then
        local tx = px + x - 1
        local ty = py + y - 1
        if isSpecial then
          tabuleiro[ty][tx] = 3
        else
          tabuleiro[ty][tx] = 2
        end
      end
    end
  end
end
--------------------------------------------------------------------------------
-- Função para limpar as linhas completas de uma única jogada.
-- Cria uma nova lista de linhas não completas e adiciona linhas vazias no topo.
local function limparLinhas()
  local linhasLimpa = 0
  local nova = {}

  for y = 1, altura do
    local completa = true
    for x = 1, largura do
      if tabuleiro[y][x] == 0 then
        completa = false
        break
      end
    end
    if completa then
      linhasLimpa = linhasLimpa + 1
    else
      table.insert(nova, tabuleiro[y])
    end
  end

  for i = 1, linhasLimpa do
    local linhaVazia = {}
    for x = 1, largura do
      linhaVazia[x] = 0
    end
    table.insert(nova, 1, linhaVazia)
  end

  tabuleiro = nova
  return linhasLimpa
end
--------------------------------------------------------------------------------
-- Função para gerar uma nova peça.
-- Retorna a peça, posição inicial (px, py) e flag isSpecial.
local function novaPeca()
  local indice = math.random(#pecas)
  local peca = pecas[indice]
  local isSpecial = (indice == #pecas)
  local px = math.floor(largura / 2)
  local py = 1
  return peca, px, py, isSpecial
end
--------------------------------------------------------------------------------

function cnt()
    gg.alert([[
🔔 **Script made for the Channel**
    📽 **Master Cheats⚜** - Created by: **Edrwuan👑**

    ➡️ **Subscribe to the Channel** for more Cheats and Game News 🎮

    🔗 **Telegram Contact**: [Click here to join](https://t.me/joinchat/IarWN9hjkgcunWEN)
    📧 **Email**: edrwuan@live.com

    📱 **Official Telegram**: @MastercheatsAnonymous



    🔔 **Script produzido para o Canal**
    📽 **Master Cheats⚜** - Criado por: **Edrwuan👑**

    ➡️ **Inscreva-se no Canal** para mais Cheats e Novidades sobre Jogos 🎮

    🔗 **Contato Telegram**: [Clique aqui para entrar](https://t.me/joinchat/IarWN9hjkgcunWEN)
    📧 **E-mail**: edrwuan@live.com

    📱 **Telegram Oficial**: @MastercheatsAnonymous
    ]])

    return
end

-- Função para exibir a mensagem de saída com um tom mais emocional
function sairJogo()
    local resposta = gg.choice({"✅Sim, sair", "❌Não, continuar"}, nil, "Você tem certeza? 😔 Quer mesmo deixar o jogo?")

    if resposta == 1 then
        -- Mensagem de despedida mais emotiva
        gg.alert("Oh não! 😢 O jogo terminou. Volte logo para se divertir mais! Até a próxima! 👋")
        os.exit()  -- Isso encerra o script
    else
        -- Mensagem de ânimo caso o jogador escolha continuar
        gg.alert("Ufa! Que bom que você decidiu continuar! 😎 Vamos nessa, boa sorte! 🍀")
    end
end

-- Função para reiniciar o jogo
local function reiniciarJogo()
  -- Zera a pontuação
  pontuacao = 0
  -- Zera o bônus
  ultimoBonus = 0
  -- Reseta o tabuleiro
  tabuleiro = {}
  for y = 1, altura do
    tabuleiro[y] = {}
    for x = 1, largura do
      tabuleiro[y][x] = 0  -- 0: célula vazia
    end
  end
  -- Gera a primeira peça
  proximaPeca, proximaPx, proximaPy, proximaIsSpecial = novaPeca()
  -- Você pode adicionar qualquer outro reset necessário para o jogo, como o nível, timer, etc.
end

function info()
gg.alert([[
🟩🟦🟥🟨 TETRIS CLASSIC 🟩🟦🟥🟨

Bem-vindo ao Tetris Clássico! 🎮

Objetivo do Jogo:
O objetivo é preencher linhas horizontais inteiras no tabuleiro com blocos coloridos que caem do topo. Quando uma linha é completada, ela desaparece, e você ganha pontos!

Como Jogar:
- Use as setas para mover as peças para a esquerda (⬅️) ou para a direita (➡️).
- Pressione 🌀 para girar a peça.
- Pressione ⏬ para fazer a peça descer mais rápido.
- O jogo termina quando o tabuleiro se enche e não há mais espaço para as peças caírem.

Lógica do Jogo:
- O tabuleiro é composto por linhas e colunas onde as peças caem.
- Cada peça é composta por quatro blocos, e existem diferentes formas de peças.
- Você precisa encaixar as peças de maneira estratégica para completar as linhas.
- A cada linha completada, você ganha pontos e o jogo fica mais rápido!

Pontuação e Combos:
- Cada linha completada dá pontos! 🏅
- Se você conseguir completar várias linhas ao mesmo tempo (combo), você ganhará **muito mais pontos!** 💥
- O bônus por combo é multiplicado da seguinte forma:
    - 1 linha = 100 pontos
    - 2 linhas = 400 pontos
    - 3 linhas = 900 pontos
    - 4 linhas = 1600 pontos
- Aproveite os combos para maximizar sua pontuação! 🎉

🎉 Boa sorte e divirta-se jogando Tetris Clássico! 🏅
]])
   return
end

-- Função para efetuar o “drop” (encaixe) da peça.
-- Para peças normais, desce até que não seja possível mover mais para baixo.
-- Para a peça especial, ela ignora obstruções e desce até o último espaço vazio na coluna.
local function descerPeca(peca, px, py, isSpecial)
  if not isSpecial then
    while podeColocarPeca(peca, px, py + 1, isSpecial) do
      py = py + 1
    end
  else
    local finalY = py
    for y = altura, py, -1 do
      if tabuleiro[y][px] == 0 then
        finalY = y
        break
      end
    end
    py = finalY
  end
  return px, py
end
--------------------------------------------------------------------------------
-- Loop principal do jogo usando gg.choice para a interação.
-- Utilizamos uma variável 'proximaPeca' para armazenar a próxima peça que será exibida.
math.randomseed(os.time())

-- Gera a primeira "próxima peça"
local proximaPeca, proximaPx, proximaPy, proximaIsSpecial = novaPeca()

while true do
  -- A peça atual será a que estava em "próxima", e geramos uma nova próxima peça
  local peca, px, py, isSpecial = proximaPeca, math.floor(largura/2), 1, proximaIsSpecial
  proximaPeca, proximaPx, proximaPy, proximaIsSpecial = novaPeca()

  -- Se a peça atual não couber na posição inicial, encerra o jogo.
  if not podeColocarPeca(peca, px, py, isSpecial) then
    gg.alert("🚨 **Jogo Finalizado!** 🚨\n\n🏆 **Sua Pontuação Final: " .. pontuacao .. "**\n\n💪 **Você mandou bem!** 💪\n\n🌟 Vamos tentar de novo e superar essa pontuação? 🌟\n\n🎮 **Clique para jogar novamente e se divertir ainda mais!** 🎮")

reiniciarJogo()
end

  -- Zera o bônus da jogada atual
  ultimoBonus = 0

  -- Suponha que você já tenha definido as funções: exibirTabuleiro(), podeColocarPeca(), girarPeca(), descerPeca(), fixarPeca(), limparLinhas(), sairJogo(), etc.

while true do
    -- Exibe o tabuleiro atualizado
    local tabuleiroExibido = exibirTabuleiro(peca, px, py, pontuacao, proximaPeca)

    -- Exibe as opções para o jogador
    local opcoes = {
      "⬅️ Mover Esquerda",
      string.rep(" ", 20).."➡️ Mover Direita",
      string.rep(" ", 60).."🌀 Girar",
      "⏬ Encaixar\n",
      "📖 Sobre este Jogo",
      "🌐 Contate Me",
      "❌ Desistir"
    }

    -- Apresenta o menu de escolha ao jogador
local escolha = gg.choice(opcoes, nil, tabuleiroExibido .. "\n🕹️Classic Tetris🧮️ GG - Game Made by MasterYT😎")

    if escolha == nil then
      os.exit()  -- Encerra o jogo se o jogador não escolher nada
    end

    if escolha == 1 then
      -- Mover para a esquerda se possível
      if podeColocarPeca(peca, px - 1, py, isSpecial) then
        px = px - 1
      end
    elseif escolha == 2 then
      -- Mover para a direita se possível
      if podeColocarPeca(peca, px + 1, py, isSpecial) then
        px = px + 1
      end
    elseif escolha == 3 then
      -- Girar a peça se possível
      local pecaRotacionada = girarPeca(peca)
      if podeColocarPeca(pecaRotacionada, px, py, isSpecial) then
        peca = pecaRotacionada
      end
    elseif escolha == 4 then
      -- Descer a peça e fixar no tabuleiro
      px, py = descerPeca(peca, px, py, isSpecial)
      fixarPeca(peca, px, py, isSpecial)

      -- Limpar linhas se necessário
      local linhas = limparLinhas()
      gg.toast("Linhas limpas: " .. linhas)  -- Mensagem de depuração

      if linhas > 0 then
        -- Calcular bônus de acordo com as linhas limpas
        local mult = linhas
        local pontosGanho = linhas * 100 * mult
        pontuacao = pontuacao + pontosGanho
        ultimoBonus = pontosGanho  -- Armazena o bônus desta jogada
        gg.toast("🎉 Bônus desta jogada: " .. ultimoBonus .. " 🏅 pts!")
      else
        ultimoBonus = 0
      end

      -- Exibir o tabuleiro após a ação
      exibirTabuleiro()

      -- Sair do loop para gerar uma nova peça
      break
    elseif escolha == 5 then
      info()
    elseif escolha == 6 then
      cnt()
    elseif escolha == 7 then
      -- Opção de sair do jogo
      sairJogo()
      break
    end

    -- Verificar se a peça pode descer, se não, fixa a peça automaticamente
    if not podeColocarPeca(peca, px, py + 1, isSpecial) then
      fixarPeca(peca, px, py, isSpecial)

      local linhas = limparLinhas()
      gg.toast("Linhas limpas: " .. linhas)

      if linhas > 0 then
        local mult = linhas
        local pontosGanho = linhas * 100 * mult
        pontuacao = pontuacao + pontosGanho
        ultimoBonus = pontosGanho  -- Armazena o bônus desta jogada
      else
        ultimoBonus = 0
      end

      -- Sair do loop para gerar uma nova peça
      break
    end
  end
end