Crie Jogos 2D com Tiniest2D

Sistema de Colisão

Como Funciona

• Cada objeto tem um colisor retangular baseado no tamanho do seu sprite
• Sprites podem ter limites de colisor personalizados (definidos no Editor de Sprites)
• A rotação do objeto rotaciona o colisor em torno do deslocamento do centro do objeto
• A colisão usa SAT (Teorema do Eixo Separador), então retângulos rotacionados colidem com sua forma rotacionada real
• A colisão é verificada a cada quadro para objetos dinâmicos

Tipos de Colisão Explicados

1. Nenhuma - O objeto é completamente ignorado pelo sistema de colisão
2. Estático - Age como uma parede imóvel (use para terreno, plataformas)
3. Dinâmico - Move-se e é empurrado para fora de outros colisor (use para jogador, inimigos)
4. Gatilho - Detecta sobreposição, mas não bloqueia movimento (use para coletáveis, zonas)

Resolução de Colisão

• Objetos dinâmicos são automaticamente empurrados para fora de objetos Estáticos e outros Dinâmicos
• Gatilhos nunca bloqueiam movimento - eles apenas detectam sobreposições
• Colisores rotacionados são resolvidos na direção da menor sobreposição

O Callback onCollision

A função onCollision(objA, objB) é chamada quando os objetos se sobrepõem. Os padrões de callback são:

Regras chave:

• objA é sempre Dinâmico ou Gatilho
• Quando dois objetos Dinâmicos colidem, ambos recebem um callback (cada um como objA)
• Quando dois Gatilhos se sobrepõem, um callback é gerado (primeiro gatilho como objA)
• Objetos Estáticos nunca aparecem como objA

Exemplo: Detectando Diferentes Tipos de Colisão

func onCollision(objA, objB) {
    var tipoA = getCollisionType(objA)
    var tipoB = getCollisionType(objB)

    // Jogador (dinâmico) tocando uma moeda (gatilho)
    if (getName(objA) == "player" && tipoB == COLLISION_TRIGGER()) {
        print("Coletado!")
        removeObject(gameScene, objB)
    }

    // Dois gatilhos se sobrepondo (por exemplo, zonas de detecção)
    if (tipoA == COLLISION_TRIGGER() && tipoB == COLLISION_TRIGGER()) {
        print(getName(objA) + " entrou na zona de " + getName(objB))
    }

    // Jogador atingido por inimigo (ambos dinâmicos)
    if (getName(objA) == "player" && getName(objB) == "enemy") {
        print("Jogador atingido!")
    }
}

Sistema de Física

O Tiniest Engine tem um sistema de física embutido que lida automaticamente com gravidade e velocidade para objetos dinâmicos.

Como a Física Funciona

A cada quadro, o motor automaticamente:

1. Aplica a gravidade da cena à velocidade de cada objeto dinâmico
2. Aplica a velocidade à posição de cada objeto dinâmico

// Pipeline de física (gerido automaticamente pelo motor):
velocity += gravity * dt
position += velocity * dt

Configurando a Gravidade

Defina a gravidade em uma cena para fazer objetos dinâmicos caírem:

func start() {
    // Define a gravidade para baixo (300 pixels por segundo ao quadrado)
    setGravityY(gameScene, 300)

    // Opcional: gravidade horizontal (efeito de vento)
    setGravityX(gameScene, 0)

    setScene(gameScene)
}

Usando Velocidade

Controle objetos usando velocidade em vez de definir diretamente a posição:

var player = Object("player")
var jumpForce = -200  // Negativo = para cima

func start() {
    setCollisionType(player, COLLISION_DYNAMIC())
    addObject(gameScene, player)
    setGravityY(gameScene, 300)
    setScene(gameScene)
}

func onUpdate(dt) {
    // Movimento horizontal via velocidade
    if (isKeyHeld(KEY_LEFT())) {
        setVelocityX(player, -100)
    } else if (isKeyHeld(KEY_RIGHT())) {
        setVelocityX(player, 100)
    } else {
        setVelocityX(player, 0)
    }

    // Pular definindo velocidade para cima
    if (isKeyPressed(KEY_SPACE())) {
        setVelocityY(player, jumpForce)
    }
}

Funções de Física

Importante: Apenas objetos COLLISION_DYNAMIC() são afetados pela gravidade e têm sua velocidade aplicada automaticamente.