O Tectris é um jogo educacional desenvolvido em C que combina a mecânica clássica do Tetris com desafios de lógica de programação. Durante a partida, os jogadores precisam resolver questões em tempo real para influenciar diretamente seu desempenho no jogo.
A proposta do projeto é transformar o aprendizado de lógica em uma experiência prática, dinâmica e competitiva, estimulando o raciocínio lógico, a tomada de decisões rápidas e o engajamento do usuário.
Diferente de métodos tradicionais, o Tectris integra o conhecimento à gameplay, permitindo que o jogador aprenda enquanto joga, tornando o processo mais intuitivo e eficaz.
As funcionalidades do Tectris foram definidas com base em histórias de usuário estruturadas no padrão 3Cs (Card, Conversation, Confirmation), garantindo rastreabilidade, clareza de requisitos e validação objetiva das entregas.
As features estão organizadas por nível de prioridade e impacto no core do sistema.
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero iniciar uma partida local contra outro jogador para competir em tempo real. |
| Conversation | • Execução síncrona para dois jogadores no mesmo dispositivo • Inicialização simultânea de dois game loops independentes • Separação lógica de estados (Player 1 e Player 2) • Renderização paralela de dois tabuleiros |
| Confirmation | • [ ] Dois jogadores conseguem iniciar uma sessão simultânea • [ ] Cada jogador possui estado isolado (grid, score, peças) • [ ] Loop principal mantém sincronização entre os jogadores |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero visualizar blocos caindo no estilo Tetris para jogar de forma intuitiva. |
| Conversation | • Implementação de grid 10x20 por jogador • Sistema de queda automática baseado em tempo (tick rate) • Controle de input (movimento lateral e rotação) • Sistema de colisão e fixação de peças • Geração pseudo-aleatória de peças (Tetrominos) |
| Confirmation | • [ ] Blocos caem com base em tempo configurável • [ ] Inputs do usuário alteram posição corretamente • [ ] Colisões são detectadas sem inconsistência • [ ] Peças são fixadas corretamente no grid |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero responder perguntas de lógica durante a partida para influenciar meu desempenho. |
| Conversation | • Sistema de eventos que dispara perguntas durante o gameplay • Estrutura de dados para armazenar perguntas (array/struct) • Usuário digita a resposta • Associação de dificuldade a cada pergunta |
| Confirmation | • [ ] Perguntas são exibidas em momentos definidos do jogo • [ ] Jogador consegue digitar a resposta • [ ] Sistema valida a resposta corretamente • [ ] Resultado é persistido no estado do jogo |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero ganhar pontos ao acertar perguntas para medir meu desempenho. |
| Conversation | • Pontuação baseada na dificuldade da pergunta • Atualização em tempo real do score • Armazenamento separado por jogador |
| Confirmation | • [ ] Pontuação incrementa corretamente por acerto • [ ] Valores variam conforme dificuldade • [ ] Interface reflete atualização em tempo real |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero sofrer penalidades ao errar perguntas para tornar o jogo desafiador. |
| Conversation | • Redução de pontuação • Inserção de blocos extras (penalidade visual) • Impacto direto no estado do grid |
| Confirmation | • [ ] Penalidade aplicada imediatamente após erro • [ ] Estado do jogador é alterado corretamente • [ ] Feedback visual reforça penalidade |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero que o jogo declare um vencedor ao atingir 100 pontos. |
| Conversation | • Definição de condição de término baseada em score • Interrupção do game loop • Exibição de tela de resultado |
| Confirmation | • [ ] Jogo encerra ao atingir 100 pontos • [ ] Vencedor é corretamente identificado • [ ] Interface exibe resultado final |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero ter tempo limitado para responder perguntas para aumentar a dificuldade. |
| Conversation | • Timer associado a cada pergunta • Redução progressiva do tempo ao longo da partida • Integração com loop principal |
| Confirmation | • [ ] Timer é exibido na interface • [ ] Tempo reduz progressivamente • [ ] Resposta inválida ao expirar o tempo |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero uma interface clara para entender o jogo facilmente. |
| Conversation | • Layout dividido em três áreas (Player 1, Centro, Player 2) • Exibição de score, tempo e perguntas • Hierarquia visual definida |
| Confirmation | • [ ] Interface apresenta informações essenciais • [ ] Elementos são legíveis e organizados • [ ] Navegação é intuitiva |
| Elemento | Descrição |
|---|---|
| Card | Como sistema, quero carregar perguntas locais para manter o jogo funcional offline. |
| Conversation | • Armazenamento em estrutura estática (array/struct) • Carregamento em memória na inicialização • Sem dependência de serviços externos |
| Confirmation | • [ ] Perguntas são carregadas corretamente • [ ] Sistema funciona sem conexão externa • [ ] Estrutura de dados é acessível durante o jogo |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero afetar o adversário ao acertar perguntas para aumentar a competitividade. |
| Conversation | • Eventos que impactam o estado do adversário • Exemplo: forçar nova pergunta, atrasar progresso • Sincronização entre estados dos jogadores |
| Confirmation | • [ ] Ação de um jogador afeta o outro • [ ] Sistema mantém consistência entre estados • [ ] Feedback visual é exibido |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero que o jogo fique mais difícil ao longo do tempo. |
| Conversation | • Aumento da velocidade de queda • Redução do tempo de resposta • Escalonamento baseado em tempo de jogo |
| Confirmation | • [ ] Velocidade aumenta gradualmente • [ ] Tempo de resposta diminui • [ ] Jogabilidade se torna mais desafiadora |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero receber feedback visual ao responder perguntas. |
| Conversation | • Uso de cores semânticas (verde/vermelho) • Animações de resposta • Destaque visual de estados |
| Confirmation | • [ ] Feedback imediato ao responder • [ ] Cores representam corretamente o estado • [ ] Interface reforça ações do usuário |
| Elemento | Descrição |
|---|---|
| Card | Como sistema, quero gerar um número aleatório para que o jogador tenha um desafio de adivinhação durante a partida. |
| Conversation | • Geração de número pseudo-aleatório • Intervalo definido (ex: 1 a 10 ou 1 a 100) • Número oculto para o jogador |
| Confirmation | • [ ] Número é gerado a cada nova rodada • [ ] Valor está dentro do intervalo definido • [ ] Número não é exibido ao jogador |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero tentar adivinhar o número até acertar para progredir no jogo. |
| Conversation | • Sistema deve permitir múltiplas tentativas • Loop continua até acerto ou condição de parada • Integração com fluxo principal do jogo |
| Confirmation | • [ ] Jogador pode inserir múltiplas tentativas • [ ] Loop continua enquanto não houver acerto • [ ] Loop é encerrado corretamente ao acertar |
| Elemento | Descrição |
|---|---|
| Card | Como sistema, quero validar a entrada do jogador para evitar erros e garantir funcionamento correto. |
| Conversation | • Verificar se entrada é numérica • Validar se está dentro do intervalo permitido • Tratar entradas inválidas |
| Confirmation | • [ ] Entrada inválida é identificada • [ ] Sistema impede valores fora do intervalo • [ ] Mensagem de erro é exibida quando necessário |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero saber quando meu palpite está abaixo do valor correto para ajustar minha estratégia. |
| Conversation | • Comparação entre palpite e número secreto • Feedback textual exibido na interface |
| Confirmation | • [ ] Sistema identifica quando valor é menor • [ ] Mensagem “Muito baixo” é exibida corretamente |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero saber quando meu palpite está acima do valor correto para ajustar minha estratégia. |
| Conversation | • Comparação entre palpite e número secreto • Feedback textual exibido na interface |
| Confirmation | • [ ] Sistema identifica quando valor é maior • [ ] Mensagem “Muito alto” é exibida corretamente |
| Elemento | Descrição |
|---|---|
| Card | Como jogador, quero ser informado quando acertar o número para receber recompensa no jogo. |
| Conversation | • Comparação direta entre palpite e número secreto • Integração com sistema de pontuação |
| Confirmation | • [ ] Sistema identifica acerto corretamente • [ ] Mensagem “Acertou” é exibida • [ ] Pontuação ou bônus é aplicado |
O protótipo inicial do Tectris foi desenvolvido com o objetivo de validar conceitos fundamentais de interação, fluxo de navegação e organização da interface, antes da implementação visual definitiva.
A abordagem adotada priorizou alta fidelidade, permitindo fiel iteração, coleta de feedback e ajustes baseados em princípios de Interação Humano-Computador (IHC).
Assista ao vídeo de demostração
- Validar a estrutura geral da interface
- Definir o fluxo principal do jogo
- Testar a disposição dos elementos em tela
- Reduzir complexidade antes da implementação visual
- Identificar problemas de usabilidade precocemente
O layout foi organizado em três áreas principais:
| 🟨 Player 1 (Esquerda) | Centro (Interação) | 🟦 Player 2 (Direita) |
|---|---|---|
| Tabuleiro (grid 10x20) | Logo do jogo | Tabuleiro (grid 10x20) |
| Área de próxima peça (NEXT) | Card de pergunta (código + alternativas) | Área de próxima peça |
| Exibição de pontuação | Botões de resposta | Exibição de pontuação |
| Barra de tempo | ||
| Contador de tempo |
Clique no titulo da funcionalidade para acessar o diagrama correspondente completo
O protótipo foi projetado com base em princípios de usabilidade:
-
Visibilidade do sistema:
Timer e pontuação sempre visíveis -
Feedback imediato:
Respostas geram retorno instantâneo -
Consistência:
Estrutura simétrica entre jogadores -
Reconhecimento ao invés de memorização:
Interface clara e previsível
O protótipo foi utilizado em testes rápidos com usuários simulados para avaliar:
- Facilidade de compreensão da interface
- Clareza das ações disponíveis
- Tempo de resposta às perguntas
- Entendimento do fluxo do jogo
- Necessidade de destacar melhor o tempo restante
- Melhorar hierarquia visual da pergunta
- Ajustar tamanho dos botões de resposta
- Reforçar feedback visual (cores e animações)
- Figma (prototipação e wireframe)
- Estrutura baseada em grid e componentes reutilizáveis
O protótipo de baixa fidelidade serviu como base para:
- Definição do design system
- Construção do protótipo de alta fidelidade
- Validação de critérios de usabilidade
A utilização de prototipação inicial permitiu identificar problemas de interação antes da implementação, reduzindo retrabalho e melhorando a experiência do usuário desde as primeiras etapas do projeto.
O Tectris foi desenvolvido seguindo uma arquitetura modular, com separação de responsabilidades, visando facilitar a manutenção, escalabilidade e organização do código.
A aplicação adota um modelo baseado em camadas lógicas, estruturado em componentes independentes que se comunicam por meio de interfaces bem definidas.
O sistema é dividido nos seguintes módulos principais:
- Core: responsável pelo controle do loop principal do jogo, gerenciamento de estados e sincronização das execuções.
- Game Engine: implementa as regras do Tetris, incluindo movimentação, rotação, colisão e fixação de blocos.
- Logic Engine: gerencia o sistema de perguntas, validação de respostas e aplicação de efeitos no jogo.
- UI Layer: responsável pela renderização dos elementos visuais e exibição das informações ao usuário.
- Input Handler: trata as entradas do usuário, convertendo interações em ações no sistema.
- Utils: contém funções auxiliares reutilizáveis.
A execução do sistema segue um ciclo contínuo baseado em um game loop:
- Inicialização dos estados do jogo
- Captura de entrada do usuário
- Atualização da lógica do jogo
- Processamento de eventos (ex: perguntas)
- Renderização da interface
- Repetição do ciclo até condição de término
Cada jogador possui um estado independente, contendo:
- Grid (tabuleiro)
- Peça atual e próxima
- Pontuação
- Status de jogo
Essa separação garante isolamento lógico e evita interferência direta entre os jogadores, exceto em eventos competitivos controlados.
A comunicação entre os módulos ocorre de forma desacoplada, por meio de chamadas de função e estruturas de dados compartilhadas, reduzindo dependências e aumentando a coesão interna de cada componente.
A arquitetura foi projetada para:
- Garantir clareza na separação de responsabilidades
- Facilitar testes e manutenção
- Permitir evolução incremental do sistema
- Suportar futuras extensões, como novos modos de jogo
Por se tratar de uma aplicação local, a arquitetura não contempla:
- Comunicação em rede
- Persistência em banco de dados
- Processamento distribuído
A mecânica do Tectris integra elementos clássicos do Tetris com um sistema interativo de resolução de problemas, criando uma experiência híbrida entre jogo e aprendizado.
O jogo utiliza um grid bidimensional de dimensões 10x20 para cada jogador, no qual peças (tetrominós) são geradas e inseridas continuamente.
As principais regras incluem:
- Queda automática de peças baseada em um intervalo de tempo (tick rate)
- Movimentação lateral e rotação controladas pelo usuário
- Detecção de colisão com limites do grid e outras peças
- Fixação da peça ao atingir uma posição válida final
Esse sistema constitui o núcleo da jogabilidade, exigindo coordenação motora e percepção espacial.
Durante a execução do jogo, eventos de interrupção são acionados para apresentar perguntas de lógica de programação aos jogadores.
Características principais:
- Perguntas exibidas simultaneamente para ambos os jogadores
- Estrutura com múltiplas alternativas (2 a 3 opções)
- Conteúdo baseado em conceitos fundamentais da linguagem C
A resposta do jogador impacta diretamente o estado do jogo, integrando aprendizado à mecânica principal.
O sistema de progressão é baseado na relação entre acertos e erros:
-
Acerto:
- Incremento de pontuação
- Possível vantagem estratégica (ex: impacto no adversário)
-
Erro:
- Redução de pontuação
- Aplicação de penalidades (ex: inserção de blocos adicionais)
Esse equilíbrio promove um ambiente competitivo e dinâmico.
A partida é encerrada quando um dos jogadores atinge a pontuação máxima estabelecida (100 pontos).
Ao término:
- O loop principal é interrompido
- O vencedor é identificado e exibido na interface
O jogo incorpora interação indireta entre os jogadores, onde ações individuais podem afetar o adversário.
Exemplos:
- Ativação de eventos que forçam o oponente a responder novas perguntas
- Alterações no ritmo de jogo do adversário
Essa mecânica adiciona uma camada estratégica ao gameplay.
Cada pergunta possui um tempo limite para resposta, controlado por um sistema de temporização integrado ao loop principal.
- O tempo disponível diminui progressivamente ao longo da partida
- A ausência de resposta dentro do limite é tratada como erro
Esse mecanismo aumenta a pressão cognitiva e a intensidade do jogo.
A dificuldade do jogo evolui dinamicamente com base no tempo de execução:
- Aumento da velocidade de queda das peças
- Redução do tempo de resposta das perguntas
Essa progressão garante manutenção do desafio e engajamento contínuo.
A mecânica do Tectris foi projetada para integrar habilidades cognitivas (raciocínio lógico) e motoras (controle de peças), promovendo uma experiência de aprendizado ativa e competitiva. sistema competitivo
- O Tectris pode incluir um modo multiplayer, onde jogadores competem em tempo real para ver quem consegue a maior pontuação ou eliminar mais linhas.
- Rankings online para incentivar a competição e o engajamento contínuo.
 |
|---|
| Larissa Lira |
| Product Owner (PO) |
| 🔗 LinkedIn • GitHub |
 |
|---|
| Diogo Alcelino |
| Scrum Master |
| 🔗 LinkedIn • GitHub |
 |
|---|
| João Rafael Morato |
| Tech Lead |
| 🔗 LinkedIn • GitHub |
 |
|---|
| Emily Raquel |
| Desenvolvedora Frontend |
| 🔗 LinkedIn • GitHub |
 |
|---|
| Cecília Lopes |
| Desenvolvedora Frontend |
| 🔗 LinkedIn • GitHub |
 |
|---|
| Alice Sena |
| Desenvolvedora Backend |
| 🔗 LinkedIn • GitHub |
 |
|---|
| Matheus Vaz |
| Desenvolvedor Backend |
| 🔗 LinkedIn • GitHub |
 |
|---|
| Kezia Aguiar |
| Designer |
| 🔗 LinkedIn • GitHub |
MIT License
Copyright (c) 2026 TE-C-TRIS
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
