Warp drive style animation in GameMaker

//Warp drive style animation by oliver @pixelchipcode
// Create Event
num_boxes = 300
boxes = array_create(num_boxes);
for (var i = 0; i < num_boxes; i++) {
    boxes[i] = {
        x3d: random_range(-1000, 1000),
        y3d: random_range(-1000, 1000),
        z3d: random_range(500, 5000),
        size3d: random_range(20, 100)
    };
}
screen_center_x = room_width / 2;
screen_center_y = room_height / 2;
scale_factor = 10
vanishing_point_y = room_height * 0.55; // Slightly below center
min_z = 10; // Reduced minimum Z distance

current_value = 3;
target_value = 100;
ease_duration = 60; // duration in steps
ease_time = 0;
is_easing = false;
shake_magnitude = 1.5; // The magnitude of the position shake
angle_magnitude = 0.005; // The magnitude of the angle shake (very subtle)
shake_x = 0; // To store shake offsets
shake_y = 0; // To store shake offsets
shake_angle = 0; // To store the angle shake

// Camera-related variables
camera = view_camera[0];
// Get the current camera
original_cam_x = camera_get_view_x(camera); // Store original camera X position
original_cam_y = camera_get_view_y(camera); // Store original camera Y position
original_cam_angle = 0; // Store original camera angle (no rotation) (no rotation)m_y = camera_get_view_y(camera); // Store original camera Y position

// EaseInQuad function
function EaseInQuad(time, start, dest, duration) {
    time /= duration;
    return dest * time * time + start;
}

// Step Event
scale_factor = current_value

for (var i = 0; i < num_boxes; i++) {
    boxes[i].z3d -= 10;
    if (boxes[i].z3d <= min_z) {
        boxes[i].z3d = random_range(4000, 5000);
        boxes[i].x3d = random_range(-1000, 1000);
        boxes[i].y3d = random_range(-1000, 1000);
        boxes[i].size3d = random_range(20, 100);
    }

    // Limit box size based on distance
    var max_size = boxes[i].z3d / 5; // Adjusted for larger boxes when close
    boxes[i].size3d = min(boxes[i].size3d, max_size);
}

// Sort boxes by z-depth (descending order)
array_sort(boxes, function(a, b) {
    return b.z3d - a.z3d;
});


if (keyboard_check_pressed(vk_space)) {
    if (current_value == 3) {
        target_value = 100;
    } else {
        target_value = 3;
    }
    ease_time = 0;
    is_easing = true;
}

if (is_easing) {
    ease_time += 1;

    if (ease_time >= ease_duration) {
        ease_time = ease_duration;
        is_easing = false;
    }

    // Apply the EaseInQuad function
    current_value = EaseInQuad(ease_time, current_value, target_value - current_value, ease_duration);
}

// Check if the value is around 10 or less and apply subtle camera shake
if (current_value <= 10) {
    // Random position shake
    shake_x = random_range(-shake_magnitude, shake_magnitude);
    shake_y = random_range(-shake_magnitude, shake_magnitude);

    // Random angle shake (very subtle)
    shake_angle = random_range(-angle_magnitude, angle_magnitude);

    // Apply the shake to the camera's position
    camera_set_view_pos(camera, original_cam_x + shake_x, original_cam_y + shake_y);

    // Apply the shake to the camera's angle (keeping it very subtle)
    camera_set_view_angle(camera, original_cam_angle + radtodeg(shake_angle)); // Apply angle in degrees
} else {
    // Reset camera position and angle when not shaking
    camera_set_view_pos(camera, original_cam_x, original_cam_y);
    camera_set_view_angle(camera, original_cam_angle);
}

// Draw Event
draw_set_color(c_white);
gpu_set_blendmode(bm_add);
for (var i = 0; i < num_boxes; i++) {
    var box = boxes[i];

    // Skip boxes that are too far
    if (box.z3d > 5000) continue;

    var half_size = box.size3d / 2;
    var vertices_3d = [
        [box.x3d - half_size, box.y3d - half_size, box.z3d - half_size],
        [box.x3d + half_size, box.y3d - half_size, box.z3d - half_size],
        [box.x3d + half_size, box.y3d + half_size, box.z3d - half_size],
        [box.x3d - half_size, box.y3d + half_size, box.z3d - half_size],
        [box.x3d - half_size, box.y3d - half_size, box.z3d + half_size],
        [box.x3d + half_size, box.y3d - half_size, box.z3d + half_size],
        [box.x3d + half_size, box.y3d + half_size, box.z3d + half_size],
        [box.x3d - half_size, box.y3d + half_size, box.z3d + half_size]
    ];

    var vertices_2d = [];
    var is_visible = true;
    for (var j = 0; j < 8; j++) {
        var vx = vertices_3d[j][0];
        var vy = vertices_3d[j][1];
        var vz = max(vertices_3d[j][2], min_z); // Prevent division by zero

        var screen_x = (vx / vz) * scale_factor + screen_center_x;
        var screen_y = (vy / vz) * scale_factor + vanishing_point_y;

        vertices_2d[j] = [screen_x, screen_y];
    }

    // Calculate alpha based on distance and position
    var dist_factor = clamp((box.z3d - min_z) / (5000 - min_z), 0, 1);
    var edge_factor = min(
        abs(screen_center_x - vertices_2d[0][0]) / screen_center_x,
        abs(screen_center_y - vertices_2d[0][1]) / screen_center_y
    );
    var alpha = 1 - (dist_factor * 0.7 + edge_factor * 0.3);
    draw_set_alpha(alpha);

    // Draw the box
    for (var j = 0; j < 4; j++) {
        draw_line(vertices_2d[j][0], vertices_2d[j][1], vertices_2d[(j+1) % 4][0], vertices_2d[(j+1) % 4][1]);
        draw_line(vertices_2d[j+4][0], vertices_2d[j+4][1], vertices_2d[4 + ((j+1) % 4)][0], vertices_2d[4 + ((j+1) % 4)][1]);
        draw_line(vertices_2d[j][0], vertices_2d[j][1], vertices_2d[j+4][0], vertices_2d[j+4][1]);
    }
}
draw_set_alpha(1);
gpu_set_blendmode(bm_normal)