307 lines
9.2 KiB
Zig
307 lines
9.2 KiB
Zig
const rl = @import("raylib");
|
|
const std = @import("std");
|
|
const Allocator = std.mem.Allocator;
|
|
const assert = std.debug.assert;
|
|
|
|
const friction = 0.99;
|
|
const walkForce = 4000;
|
|
const maxSpeed = 200;
|
|
const handDistance = 50;
|
|
|
|
const Enemy = struct {
|
|
position: rl.Vector2,
|
|
};
|
|
|
|
const Player = struct {
|
|
position: rl.Vector2,
|
|
velocity: rl.Vector2 = rl.Vector2.zero(),
|
|
acceleration: rl.Vector2 = rl.Vector2.zero(),
|
|
handDirection: rl.Vector2 = rl.Vector2{ .x = 1, .y = 0 }
|
|
};
|
|
|
|
const Rope = struct {
|
|
const maxNodes = 64;
|
|
const NodeArray = std.BoundedArray(rl.Vector2, maxNodes);
|
|
|
|
nodePositions: NodeArray,
|
|
nodeVelocities: NodeArray,
|
|
segmentLength: f32,
|
|
springForce: f32 = 10,
|
|
|
|
leftoverTime: f32 = 0,
|
|
friction: f32 = 0.0005,
|
|
|
|
fn init(from: rl.Vector2, to: rl.Vector2, nodeCount: u32) Rope {
|
|
assert(nodeCount <= maxNodes);
|
|
var nodePositions = NodeArray.init(nodeCount) catch unreachable;
|
|
|
|
const diff = to.sub(from);
|
|
const segmentLength = diff.length() / @as(f32, @floatFromInt(nodeCount));
|
|
const segmentStep = diff.normalize().scale(segmentLength);
|
|
|
|
nodePositions.set(0, from);
|
|
for (1..nodeCount) |i| {
|
|
const nextNode = nodePositions.get(i-1).add(segmentStep);
|
|
nodePositions.set(i, nextNode);
|
|
}
|
|
|
|
var nodeVelocities = NodeArray.init(nodeCount) catch unreachable;
|
|
for (nodeVelocities.slice()) |*vel| {
|
|
vel.* = rl.Vector2.zero();
|
|
}
|
|
|
|
return Rope{
|
|
.nodePositions = nodePositions,
|
|
.nodeVelocities = nodeVelocities,
|
|
.segmentLength = segmentLength
|
|
};
|
|
}
|
|
|
|
fn update(self: *Rope, dt: f32) void {
|
|
const timestep = 1.0/(60.0 * 100);
|
|
self.leftoverTime += dt;
|
|
while (self.leftoverTime >= timestep) : (self.leftoverTime -= timestep) {
|
|
self.update_step(timestep);
|
|
}
|
|
}
|
|
|
|
fn update_step(self: *Rope, dt: f32) void {
|
|
var offsets = NodeArray.init(self.nodePositions.len) catch unreachable;
|
|
for (offsets.slice()) |*offset| {
|
|
offset.* = rl.Vector2.zero();
|
|
}
|
|
|
|
var accelerations = NodeArray.init(self.nodePositions.len) catch unreachable;
|
|
for (accelerations.slice()) |*acc| {
|
|
acc.* = rl.Vector2.zero();
|
|
}
|
|
|
|
const node_count = self.nodePositions.len;
|
|
for (1..node_count) |i| {
|
|
const node1: rl.Vector2 = self.nodePositions.get(i-1);
|
|
const node2: rl.Vector2 = self.nodePositions.get(i);
|
|
const node_diff = node2.sub(node1);
|
|
const node_dir = node_diff.normalize();
|
|
|
|
const rope_force = node_diff.length() - self.segmentLength;
|
|
const d = node_dir.scale(rope_force);
|
|
|
|
offsets.set(i-1, offsets.get(i-1).add(d.scale(0.5)));
|
|
offsets.set(i , offsets.get(i ).add(d.scale(-0.5)));
|
|
|
|
accelerations.set(i-1, accelerations.get(i-1).add(d));
|
|
accelerations.set(i , accelerations.get(i ).add(d.scale(-1)));
|
|
}
|
|
|
|
for (1..node_count) |i| {
|
|
const pos = &self.nodePositions.slice()[i];
|
|
const vel = &self.nodeVelocities.slice()[i];
|
|
const acc = accelerations.get(i);
|
|
const offset = offsets.get(i);
|
|
vel.* = vel.add(acc.scale(dt));
|
|
vel.* = vel.scale(1 - self.friction);
|
|
pos.* = pos.add(vel.scale(dt*10000));
|
|
pos.* = pos.add(offset.scale(0.01));
|
|
}
|
|
}
|
|
};
|
|
|
|
allocator: Allocator,
|
|
prng: std.rand.DefaultPrng,
|
|
|
|
enemyTimer: f32 = 0,
|
|
spawnedEnemiesCount: u32 = 0,
|
|
killCount: u32 = 0,
|
|
enemies: std.ArrayList(Enemy),
|
|
player: Player,
|
|
rope: Rope,
|
|
|
|
const Self = @This();
|
|
|
|
pub fn init(allocator: Allocator) Self {
|
|
var playerPosition = rl.Vector2{ .x = 400, .y = 400 };
|
|
var ropeSize: f32 = 200;
|
|
var handPosition = playerPosition.add(rl.Vector2{ .x = handDistance, .y = 0});
|
|
|
|
return Self {
|
|
.allocator = allocator,
|
|
.prng = std.rand.DefaultPrng.init(@bitCast(std.time.timestamp())),
|
|
.enemies = std.ArrayList(Enemy).init(allocator),
|
|
.player = .{ .position = playerPosition },
|
|
.rope = Rope.init(handPosition, handPosition.add(.{ .x = ropeSize, .y = 0.002 }), 10)
|
|
};
|
|
}
|
|
|
|
pub fn reset(self: *Self) void {
|
|
self.deinit();
|
|
self.* = Self.init(self.allocator);
|
|
}
|
|
|
|
pub fn deinit(self: Self) void {
|
|
self.enemies.deinit();
|
|
}
|
|
|
|
pub fn tick(self: *Self) !void {
|
|
rl.ClearBackground(rl.BLACK);
|
|
|
|
const dt = rl.GetFrameTime();
|
|
var rng = self.prng.random();
|
|
var player = &self.player;
|
|
var enemies = &self.enemies;
|
|
var rope = &self.rope;
|
|
var allocator = self.allocator;
|
|
|
|
self.enemyTimer -= dt;
|
|
if (self.enemyTimer <= 0) {
|
|
self.enemyTimer = 0.5 + rng.float(f32) * 2;
|
|
self.spawnedEnemiesCount += 1;
|
|
try enemies.append(Enemy{
|
|
.position = rl.Vector2.randomOnUnitCircle(rng).scale(100)
|
|
});
|
|
}
|
|
|
|
var inputDx: f32 = 0;
|
|
var inputDy: f32 = 0;
|
|
if (rl.IsKeyDown(rl.KeyboardKey.KEY_W)) {
|
|
inputDy -= 1;
|
|
}
|
|
if (rl.IsKeyDown(rl.KeyboardKey.KEY_S)) {
|
|
inputDy += 1;
|
|
}
|
|
if (rl.IsKeyDown(rl.KeyboardKey.KEY_A)) {
|
|
inputDx -= 1;
|
|
}
|
|
if (rl.IsKeyDown(rl.KeyboardKey.KEY_D)) {
|
|
inputDx += 1;
|
|
}
|
|
|
|
var gamepad: i32 = 0;
|
|
if (rl.IsGamepadAvailable(gamepad)) {
|
|
inputDx += rl.GetGamepadAxisMovement(gamepad, rl.GamepadAxis.GAMEPAD_AXIS_LEFT_X);
|
|
inputDy += rl.GetGamepadAxisMovement(gamepad, rl.GamepadAxis.GAMEPAD_AXIS_LEFT_Y);
|
|
}
|
|
|
|
var input_dir = rl.Vector2{ .x = inputDx, .y = inputDy };
|
|
input_dir = rl.Vector2Normalize(input_dir);
|
|
if (input_dir.x != 0 or input_dir.y != 0) {
|
|
player.handDirection = input_dir;
|
|
}
|
|
|
|
player.acceleration = input_dir;
|
|
player.acceleration = rl.Vector2Scale(player.acceleration, walkForce);
|
|
|
|
player.velocity = rl.Vector2Add(player.velocity, rl.Vector2Scale(player.acceleration, dt));
|
|
player.velocity = rl.Vector2ClampValue(player.velocity, 0, maxSpeed);
|
|
player.velocity = rl.Vector2Scale(player.velocity, std.math.pow(f32, (1 - friction), dt));
|
|
|
|
player.position = rl.Vector2Add(player.position, rl.Vector2Scale(player.velocity, dt));
|
|
|
|
const enemySize: f32 = 20;
|
|
const deathBallSize: f32 = 10;
|
|
const playerSize = 20;
|
|
|
|
const enemySpeed = 100;
|
|
for (enemies.items) |*enemy| {
|
|
const toPlayer = player.position.sub(enemy.position);
|
|
if (toPlayer.length() <= playerSize + enemySize) {
|
|
self.reset();
|
|
return;
|
|
}
|
|
|
|
const directionToPlayer = toPlayer.normalize();
|
|
enemy.position = enemy.position.add(directionToPlayer.scale(enemySpeed * dt));
|
|
rl.DrawCircle(
|
|
@intFromFloat(enemy.position.x),
|
|
@intFromFloat(enemy.position.y),
|
|
enemySize,
|
|
rl.RED
|
|
);
|
|
}
|
|
|
|
const handPosition = player.position.add(player.handDirection.scale(handDistance));
|
|
|
|
const enemyCountText = try std.fmt.allocPrintZ(allocator, "{d}", .{self.spawnedEnemiesCount});
|
|
defer allocator.free(enemyCountText);
|
|
rl.DrawText(enemyCountText, 10, 10, 24, rl.RED);
|
|
|
|
const killCountText = try std.fmt.allocPrintZ(allocator, "{d}", .{self.killCount});
|
|
defer allocator.free(killCountText);
|
|
rl.DrawText(killCountText, 10, 30, 24, rl.GREEN);
|
|
|
|
rl.DrawCircle(
|
|
@intFromFloat(player.position.x),
|
|
@intFromFloat(player.position.y),
|
|
playerSize,
|
|
rl.RAYWHITE
|
|
);
|
|
rl.DrawCircle(
|
|
@intFromFloat(handPosition.x),
|
|
@intFromFloat(handPosition.y),
|
|
5,
|
|
rl.RAYWHITE
|
|
);
|
|
rl.DrawLine(
|
|
@intFromFloat(player.position.x),
|
|
@intFromFloat(player.position.y),
|
|
@intFromFloat(player.position.x + player.velocity.x),
|
|
@intFromFloat(player.position.y + player.velocity.y),
|
|
rl.GREEN
|
|
);
|
|
|
|
rl.DrawCircle(
|
|
@intFromFloat(player.position.x + input_dir.x * maxSpeed),
|
|
@intFromFloat(player.position.y + input_dir.y * maxSpeed),
|
|
5,
|
|
rl.GREEN
|
|
);
|
|
|
|
rope.nodePositions.set(0, handPosition);
|
|
|
|
rope.update(dt);
|
|
|
|
const rope_color = rl.PURPLE;
|
|
for (0..(rope.nodePositions.len-1)) |i| {
|
|
var node1: rl.Vector2 = rope.nodePositions.get(i);
|
|
var node2: rl.Vector2 = rope.nodePositions.get(i+1);
|
|
rl.DrawLine(
|
|
@intFromFloat(node1.x),
|
|
@intFromFloat(node1.y),
|
|
@intFromFloat(node2.x),
|
|
@intFromFloat(node2.y),
|
|
rope_color
|
|
);
|
|
}
|
|
|
|
for (rope.nodePositions.slice()) |node| {
|
|
rl.DrawCircle(
|
|
@intFromFloat(node.x),
|
|
@intFromFloat(node.y),
|
|
5,
|
|
rope_color
|
|
);
|
|
}
|
|
|
|
const deathBallPosition = rope.nodePositions.get(rope.nodePositions.len-1);
|
|
|
|
rl.DrawCircle(
|
|
@intFromFloat(deathBallPosition.x),
|
|
@intFromFloat(deathBallPosition.y),
|
|
deathBallSize,
|
|
rl.RED
|
|
);
|
|
|
|
{
|
|
var i: usize = 0;
|
|
while (i < enemies.items.len) {
|
|
const enemy = &enemies.items[i];
|
|
const distanceToDeathBall = enemy.position.sub(deathBallPosition).length();
|
|
if (distanceToDeathBall < enemySize + deathBallSize) {
|
|
self.killCount += 1;
|
|
_ = enemies.swapRemove(i);
|
|
continue;
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
}
|