Alta Performance.
Alto Nível.

// Hello World & Matemática Recursiva em HP-HL
module hello;

int Factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * Factorial(n - 1);
}

void Main() {
    print("Olá, mundo HP-HL!\n");

    int x = 42;
    print("Fatorial(5) = ");
    print(Factorial(5));
    print("\n");

    // Funções matemáticas nativas: sin, cos, sqrt, pow, PI
    float hipotenusa = sqrt(3.0 * 3.0 + 4.0 * 4.0);
    print("Hipotenusa: ");
    print(hipotenusa);
    print("\n");
}

// Multithreading com spawn, canais e sincronização de tarefas
module parallel_workers;

void Worker(int id, channel<int> ch) {
    int total = 0;
    for (int i = 0; i < 1000000; i++) {
        total += i;
    }
    ch.Send(total);
}

void Main() {
    var ch = new channel<int>();

    // Dispara tarefas assíncronas no pool de threads
    spawn Worker(1, ch);
    spawn Worker(2, ch);

    int res1 = ch.Receive();
    int res2 = ch.Receive();

    print("Trabalhadores concluíram: ");
    print(res1 + res2);
    print("\n");
}

// Interoperabilidade Direta com a API Win32 via extern
module ffi_win32;

extern "user32" int MessageBoxA(int hwnd, string text, string caption, int type);
extern "kernel32" int GetTickCount();

void Main() {
    int inicio = GetTickCount();
    
    // Executa caixa de diálogo nativa do Windows diretamente
    MessageBoxA(0, "Olá do FFI Win32 Nativo do HP-HL!", "Motor HP-HL", 0x40);
    
    int decorrido = GetTickCount() - inicio;
    print("Tempo decorrido na caixa de diálogo (ms): ");
    print(decorrido);
    print("\n");
}

// Structs de Valor (Pilha/Cache rápido) vs Classes Gerenciadas (GC)
module memory_model;

// Structs são planas, passadas por valor com rastreamento zero no GC
struct Vec3 {
    float x;
    float y;
    float z;
}

// Classes residem na heap geracional gerenciada pelo GC
class Entity {
    string name;
    Vec3 pos;

    Entity(string n, Vec3 p) {
        this.name = n;
        this.pos = p;
    }
}

void Main() {
    Vec3 v;
    v.x = 10.0; v.y = 20.0; v.z = 30.0;

    var player = new Entity("JogadorUm", v);
    print(player.name);
    print(" em (");
    print(player.pos.x);
    print(")\n");
}

// Raytracer com iluminação Phong, sombras e render paralelo
module raytracer;

class Vec3 {
    public float<64> X;
    public float<64> Y;
    public float<64> Z;
    Vec3(float<64> x, float<64> y, float<64> z) { X = x; Y = y; Z = z; }

    float<64> Dot(Vec3 o) {
        return X * o.X + Y * o.Y + Z * o.Z;
    }
    Vec3 Norm() {
        float<64> l = sqrt(this.Dot(this));
        return new Vec3(X / l, Y / l, Z / l);
    }
}

class Sphere {
    public Vec3 Center;
    public float<64> Radius;
    public Vec3 Color;

    float<64> Hit(Ray r) {
        Vec3 oc = r.Origin.Sub(Center);
        float<64> disc = oc.Dot(r.Direction) * oc.Dot(r.Direction)
                       - oc.Dot(oc) + Radius * Radius;
        if (disc < 0.0) return -1.0;
        return (-oc.Dot(r.Direction) - sqrt(disc));
    }
}

// Render paralelo: cada scanline em thread separada
parallel foreach (var y in rows) {
    RenderRow(y);  // zero-copy, thread-safe por design
}
img_png_save("cena.png", img, 1280, 720);
print("cena.png ok\n");

// SpaceShooter: jogo arcade completo com Win32 FFI nativo
import Win32;
import Vec2;
import CharBuffer;
import Input;
import Collider;
import Particles;

Vec2 shipPos;
float<64>[128] bx;
float<64>[128] by;
int[64] efire;
int nFoes;

void AddShot(float<64> x, float<64> y, float<64> vy, bool foe) {
    if (nShots >= 128) return;
    bx[nShots] = x;
    by[nShots] = y;
    nShots = nShots + 1;
}

void Main() {
    // Console game loop a 60 FPS com Win32 FFI direto
    while (gLives > 0) {
        UpdateShip();
        UpdateBullets();
        SpawnEnemies();
        CheckCollisions();
        Render();
        Sleep(16);  // ~60 FPS
    }
}