Wilson Sarruf

🕹️ Tetriz

O clássico jogo de empilhar blocos para Android, desenvolvido em Kotlin e Jetpack Compose. Inclui três modos (individual, multijogador local e VS IA), tabuleiro 10×20, top 100 de pontuações e layout adaptativo para telemóvel e tablet.

Destaques

• Motor de jogo próprio: rotação, bloqueio, níveis, pontuação e fim de jogo.
• IA heurística no modo VS AI — pondera altura das colunas, linhas completas, buracos e irregularidade.
• Persistência local (DataStore), acessibilidade TalkBack e badge PEGI.

KotlinJetpack ComposeMVVMCoroutinesDataStore

Código (exemplo)

private fun evaluateBoard(board: GameBoard): Double {
    val heights = getColumnHeights(board)
    val aggregateHeight = heights.sum()
    val completeLines = countCompleteLines(board)
    val holes = countHoles(board, heights)
    val bumpiness = calculateBumpiness(heights)

    return WEIGHT_AGGREGATE_HEIGHT * aggregateHeight +
            WEIGHT_COMPLETE_LINES * completeLines +
            WEIGHT_HOLES * holes +
            WEIGHT_BUMPINESS * bumpiness
}

Fonte: app/src/main/java/com/example/tetriz/domain/TetrisAI.kt

Prompt de código

«Cria um motor de Tetris em Kotlin/Compose com um oponente de IA heurística que pondere a altura das colunas, as linhas completas, os buracos e a irregularidade do tabuleiro.»

Aplicação Android — disponível para instalação direta no dispositivo através do APK.

const AudioEngine = (function(){
  const ctx = new (window.AudioContext || window.webkitAudioContext)();
  function play(freq, time=0.06, type='sine', gain=0.12){
    const o = ctx.createOscillator();
    const g = ctx.createGain();
    o.type = type; o.frequency.value = freq;
    g.gain.value = gain;
    o.connect(g); g.connect(ctx.destination);
    o.start();
    o.stop(ctx.currentTime + time);
  }
  function hit(){ play(880,0.08,'square',0.12); }
  function shot(){ play(600,0.06,'sawtooth',0.12); }
  function reload(){ play(220,0.12,'sine',0.08); play(330,0.12,'sine',0.08); }
  function end(){ play(120,0.18,'sine',0.18); }
  return { hit, shot, reload, end };
})();

params = {
    "geo": geo,
    "unit": "RCH_A",
    "lastTimePeriod": ultimos_periodos,
    "format": "JSON",
}
url = f"{EUROSTAT_BASE}/{DATASET_HICP}"

async with httpx.AsyncClient(timeout=20) as client:
    resp = await client.get(url, params=params)
    resp.raise_for_status()
    payload = resp.json()

public List<Solution> gerarSolucoes(FireRisk risco) {
    List<Solution> solucoes = new ArrayList<>();
    if (risco == null) {
        return solucoes;
    }
    FireRiskLevel nivel = risco.getNivelRisco();
    double temperatura = valorOuZero(risco.getTemperatura());
    double humidade = valorOuZero(risco.getHumidade());
    double vento = valorOuZero(risco.getVelocidadeVento());
    double precipitacao = valorOuZero(risco.getPrecipitacao());
    double fwi = valorOuZero(risco.getFwi());

    boolean seco = humidade <= 30.0;
    boolean ventoso = vento >= 30.0;
    boolean deficitHidrico = precipitacao < 15.0;
    ...
}

function search(d, alpha, beta) {
  if (timeLimitMs && Date.now() - start > timeLimitMs) throw 'timeout';
  if (d === 0) return evaluate(pos);
  const moves = ChessEngine.generateLegalMoves(pos);
  if (moves.length === 0) return ChessEngine.isCheck(pos, pos.side) ? -999999 : 0;
  let value = -Infinity;
  for (const m of moves) {
    const rec = ChessEngine.makeMove(pos, m);
    const v = -search(d - 1, -beta, -alpha);
    ChessEngine.undoMove(pos);
    if (v > value) { value = v; if (d === rootDepth) best = m; }
    alpha = Math.max(alpha, v);
    if (alpha >= beta) break;
  }
  return value;
}

io.on('connection', (socket) => {
  socket.on('create-room', (roomId, ack) => {
    if (!rooms.has(roomId)) rooms.set(roomId, new Set());
    if (rooms.get(roomId).size >= 2) {
      return ack && ack({ ok: false, error: 'full' });
    }
    socket.join(roomId);
    rooms.get(roomId).add(socket.id);
    if (ack) ack({ ok: true });
  });

  // Reencaminhamento efémero de sinalização WebRTC (offer/answer/ICE).
  socket.on('signal', (roomId, data) => {
    socket.to(roomId).emit('signal', { from: socket.id, data });
  });
});

/**
 * Partilha de ficheiros pesados (chunking P2P).
 * Ficheiros fatiados em blocos de 16 KB no envio; na receção,
 * o hash SHA-256 é verificado antes de guardar em Downloads.
 */
class FileTransferManager(...) {
    companion object {
        const val CHUNK = 16 * 1024L
        const val BUFFER_HIGH = 512 * 1024L
        const val BUFFER_LOW = 256 * 1024L
    }
}

const ORIGEM_PERMITIDA  = 'https://wsarruf.com';
const MAX_ENVIOS        = 5;
const JANELA_SEGUNDOS   = 600;

function resposta(bool $ok, string $mensagem, int $codigo = 200): void
{
    http_response_code($codigo);
    echo json_encode(['ok' => $ok, 'mensagem' => $mensagem], JSON_UNESCAPED_UNICODE);
    exit;
}