Exemplo 1: Classe Básica com Lógica Simples
//##############################
// Classe: Jogador - Representa um participante do jogo
Classe Jogador
nome is string
escolha is string
END

// Procedure: JogaPedraPapelTesoura - Simula o jogo entre jogador e máquina
Procedure JogaPedraPapelTesoura(nomeJogador is string)
jogador is Jogador
maquina is Jogador
opcoes is array of string = ["Pedra", "Papel", "Tesoura"]
resultado is string

// Configura o jogador
jogador..nome = nomeJogador
jogador..escolha = Input("Escolha Pedra, Papel ou Tesoura, " + nomeJogador + "!")

// Máquina escolhe aleatoriamente
maquina..nome = "Máquina Malandra"
maquina..escolha = opcoes[Rand(1, 3)]

// Mostra as escolhas
Trace(nomeJogador + " jogou: " + jogador..escolha)
Trace("Máquina jogou: " + maquina..escolha)

// Define o vencedor
IF jogador..escolha = maquina..escolha THEN
resultado = "Empate! Vocês são gêmeos do destino!"
ELSE
SWITCH jogador..escolha
CASE "Pedra":
IF maquina..escolha = "Tesoura" THEN resultado = "Vitória! Pedra esmaga Tesoura!"
ELSE resultado = "Derrota! Papel embrulha Pedra!"
CASE "Papel":
IF maquina..escolha = "Pedra" THEN resultado = "Vitória! Papel embrulha Pedra!"
ELSE resultado = "Derrota! Tesoura corta Papel!"
CASE "Tesoura":
IF maquina..escolha = "Papel" THEN resultado = "Vitória! Tesoura corta Papel!"
ELSE resultado = "Derrota! Pedra esmaga Tesoura!"
END//Switch
END//If

Info(resultado)
//##############################
Como usar: JogaPedraPapelTesoura("Adriano")
Explicação:
• Criei uma classe Jogador com nome e escolha.
• Input() captura a jogada do usuário, e Rand() faz a máquina escolher aleatoriamente.
• Usei SWITCH pra lógica do vencedor, mais elegante que um monte de IF.
• Trace() pra debug e Info() pra mostrar o resultado com humor!

Exemplo 2: Versão Avançada com Herança e Validação
//##############################
// Classe Base: Participante - Define propriedades comuns
Classe Participante
nome is string
pontos is int
END

// Classe: Humano - Herda de Participante
Classe Humano INHERITS Participante
escolha is string
END

// Classe: Maquina - Herda de Participante com IA simples
Classe Maquina INHERITS Participante
escolha is string
END

// Procedure: DueloPedraPapelTesoura - Jogo com validação e pontuação
Procedure DueloPedraPapelTesoura(nomeHumano is string)
humano is Humano
maquina is Maquina
opcoes is array of string = ["Pedra", "Papel", "Tesoura"]

// Inicializa os competidores
humano..nome = nomeHumano
humano..pontos = 0
maquina..nome = "Máquina Trapaceira"
maquina..pontos = 0

// Jogada do humano com validação
humano..escolha = Upper(Input("Escolha: Pedra, Papel ou Tesoura, " + nomeHumano + "!"))
IF NOT ArraySeek(opcoes, humano..escolha) THEN
Info("Ei, " + nomeHumano + ", só vale Pedra, Papel ou Tesoura! Tá inventando moda?")
Return
END//If

// Jogada da máquina
maquina..escolha = opcoes[Rand(1, 3)]

// Mostra o confronto
Trace(humano..nome + " vs " + maquina..nome + ": " + humano..escolha + " x " + maquina..escolha)

// Lógica do vencedor
IF humano..escolha = maquina..escolha THEN
Trace("Empate! Ninguém ganha ponto dessa vez!")
ELSE
IF (humano..escolha = "Pedra" AND maquina..escolha = "Tesoura") OR ...
(humano..escolha = "Papel" AND maquina..escolha = "Pedra") OR ...
(humano..escolha = "Tesoura" AND maquina..escolha = "Papel") THEN
humano..pontos = humano..pontos + 1
Info("Ponto pra " + humano..nome + "! Você é o cara!")
ELSE
maquina..pontos = maquina..pontos + 1
Info("Ponto pra " + maquina..nome + "! Máquina tá te humilhando!")
END//If
END//If

Trace("Placar: " + humano..nome + " " + humano..pontos + " x " + maquina..pontos + " " + maquina..nome)
//##############################
Como usar: DueloPedraPapelTesoura("Adriano")
Explicação:
• Usei herança (INHERITS) pra criar uma classe base Participante e especializar em Humano e Maquina.
• Adicionei validação com ArraySeek() pra evitar jogadas inválidas.
• Incluí pontuação pra deixar mais competitivo e divertido!

Exemplo 3: Versão MVC com Componente Visual
//##############################
// Classe: ModeloJogo - Lógica do jogo
Classe ModeloJogo
jogador is string
maquina is string
resultado is string
END

// Procedure: ControlaJogo - Controlador que gerencia o fluxo
Procedure ControlaJogo(nomeJogador is string)
jogo is ModeloJogo
opcoes is array of string = ["Pedra", "Papel", "Tesoura"]

jogo..jogador = Upper(Input("Sua jogada, " + nomeJogador + ": Pedra, Papel ou Tesoura?"))
IF NOT ArraySeek(opcoes, jogo..jogador) THEN
Info("Jogada inválida, " + nomeJogador + "! Só aceito Pedra, Papel ou Tesoura!")
Return
END//If

jogo..maquina = opcoes[Rand(1, 3)]
jogo..resultado = CalculaResultado(jogo..jogador, jogo..maquina)
ExibeResultado(jogo)
//##############################

// Procedure: CalculaResultado - Lógica separada (Model)
Procedure CalculaResultado(jogador is string, maquina is string)
IF jogador = maquina THEN
Result("Empate! Que sincronia, hein!")
END//If

SWITCH jogador
CASE "Pedra": Result(IIF(maquina = "Tesoura", "Você venceu! Pedra esmaga!", "Máquina venceu! Papel embrulha!"))
CASE "Papel": Result(IIF(maquina = "Pedra", "Você venceu! Papel embrulha!", "Máquina venceu! Tesoura corta!"))
CASE "Tesoura": Result(IIF(maquina = "Papel", "Você venceu! Tesoura corta!", "Máquina venceu! Pedra esmaga!"))
END//Switch
//##############################

// Procedure: ExibeResultado - Visão separada (View)
Procedure ExibeResultado(jogo is ModeloJogo)
mensagem is string = [
Jogador: <>
Máquina: <>
Resultado: <>
]
Info(mensagem)
//##############################