make a square move along the path

1 files changed, 85 insertions, 30 deletions

diff --git a/src/main.zig b/src/main.zig
index cb1395d..3a8fb9e 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1,4 +1,5 @@
 const engine = @import("engine");
+const math = engine.math;
 const matrix = engine.matrix;
 const Mat3 = matrix.Matrix(f32, 3, 3);
 const webgl = engine.webgl;
@@ -23,6 +24,51 @@ const plane_verts = [_][2]f32{
     .{ 1, 1 },
 };
 
+const path = [_][2]f32{
+    .{ -100, 500 },
+    .{ 300, 500 },
+    .{ 300, 150 },
+    .{ 150, 150 },
+    .{ 150, 300 },
+    .{ 650, 300 },
+    .{ 650, 550 },
+    .{ 500, 550 },
+    .{ 500, 400 },
+    .{ 900, 400 },
+};
+const path_width = 32;
+const path_len = blk: {
+    var total: comptime_float = 0;
+    for (path[0 .. path.len - 1], path[1..]) |a, b| {
+        total += distance(a, b);
+    }
+    break :blk total;
+};
+
+fn lerp(a: f32, b: f32, pct: f32) f32 {
+    return a + (b - a) * pct;
+}
+
+fn calcPathPos(progress: f32) [2]f32 {
+    var rem: f32 = progress;
+    var i: usize = 0;
+    while (i < path.len) : (i += 1) {
+        const seg_a = path[i];
+        const seg_b = path[i + 1];
+        const dist = distance(seg_a, seg_b);
+
+        if (dist > rem) {
+            const pct = rem / dist;
+            const x = lerp(seg_a[0], seg_b[0], pct);
+            const y = lerp(seg_a[1], seg_b[1], pct);
+            return .{ x, y };
+        } else {
+            rem -= dist;
+        }
+    }
+    return path[path.len - 1];
+}
+
 const Mouse = struct {
     mutex: bool = false,
     pos: [2]f32 = .{ 0, 0 },
@@ -45,11 +91,7 @@ const Mouse = struct {
 var mouse: Mouse = .{};
 var input_priority: u8 = 0;
 
-const p_count = 8;
-var points: [p_count][2]f32 = [1][2]f32{.{ 0, 0 }} ** p_count;
-
-var grab_idx: ?usize = null;
-var grab_offset: [2]f32 = undefined;
+var enemy_progress: f32 = 0;
 
 pub fn init() void {
     prog = webgl.createGeneral2DSolidProgram() catch return;
@@ -60,7 +102,14 @@ pub fn init() void {
     prog.setVertexAttribPointer(.pos, vao, buffer);
 }
 
-pub fn update() void {
+const atan2 = @import("std").math.atan2;
+
+var timer: f32 = 0;
+pub fn update(delta_time: f32) void {
+    timer += delta_time;
+    enemy_progress += delta_time * 200;
+    enemy_progress = @mod(enemy_progress, path_len);
+
     const m = blk: {
         mouse.lock();
         defer mouse.unlock();
@@ -78,38 +127,44 @@ pub fn update() void {
     };
 
     const m_vec: @Vector(2, f32) = m.pos;
-    if (m.pressed) {
-        for (points, 0..) |p, i| {
-            const bl: @Vector(2, f32) = p;
-            const tr = bl + @Vector(2, f32){ 50, 50 };
-            if (@reduce(.And, m_vec >= bl) and @reduce(.And, m_vec < tr)) {
-                grab_offset = m_vec - bl;
-                grab_idx = i;
-            }
-        }
-    } else if (m.released and grab_idx != null) {
-        points[grab_idx.?] = m_vec - grab_offset;
-        grab_idx = null;
-    } else if (grab_idx != null) {
-        points[grab_idx.?] = m_vec - grab_offset;
-    }
+    _ = m_vec;
     const dims = webgl.getScreenSize();
     webgl.viewportToScreen();
     prog.setUniform(.projection, matrix.projectionMatrix2D(dims[0], dims[1]));
     webgl.clear(bg);
     buffer.bind(.array_buffer);
 
-    for (points, 0..) |p, i| {
-        const is_grabbed = grab_idx != null and grab_idx.? == i;
-        if (is_grabbed) {
-            prog.setUniform(.color, .{ 0, 1, 0 });
-        } else {
-            prog.setUniform(.color, .{ 1, 0, 0 });
-        }
-        const model = Mat3.translation(p).scaled(.{ 50, 50 });
-        prog.setUniform(.model, model);
+    for (path[0 .. path.len - 1], path[1..]) |a, b| {
+        const offset = .{ b[0] - a[0], b[1] - a[1] };
+        const angle = atan2(offset[1], offset[0]);
+        const dist = distance(a, b);
+
+        const a_model = Mat3.translation(a).translate(.{ -10, -10 }).scaled(.{ 20, 20 });
+        prog.setUniform(.model, a_model);
+        prog.setUniform(.color, .{ 1, 0, 0 });
+        webgl.drawArrays(.triangles, 0, 6);
+
+        const path_model = Mat3.translation(a).rotateZ(angle).translate(.{ -5, -5 }).scaled(.{ dist, 10 });
+        prog.setUniform(.model, path_model);
+        prog.setUniform(.color, .{ 0, 1, 0 });
+        webgl.drawArrays(.triangles, 0, 6);
+
+        const b_model = Mat3.translation(b).translate(.{ -10, -10 }).scaled(.{ 20, 20 });
+        prog.setUniform(.model, b_model);
+        prog.setUniform(.color, .{ 0, 0, 1 });
         webgl.drawArrays(.triangles, 0, 6);
     }
+
+    const enemy_pos = calcPathPos(enemy_progress);
+    const enemy_model = Mat3.translation(enemy_pos).translate(.{ -10, -10 }).scaled(.{ 20, 20 });
+    prog.setUniform(.model, enemy_model);
+    prog.setUniform(.color, .{ 1, 0, 1 });
+    webgl.drawArrays(.triangles, 0, 6);
+}
+
+fn distance(a: [2]f32, b: [2]f32) f32 {
+    const offset = .{ b[0] - a[0], b[1] - a[1] };
+    return @sqrt((offset[0] * offset[0]) + (offset[1] * offset[1]));
 }
 
 pub fn handleInput(event: input.InputEvent) void {