RPG attributes generator: Difference between revisions

=={{header|Zig}}==

<syntaxhighlight lang="zig">const std = @import("std");

const dice = 6;

const rolls = 4;

const stat_count = 6;

// requirements

const min_stat_sum = 75;

const min_high_stat_count = 2;

const high_stat_threshold = 15;

const RollResult = struct { stats: [stat_count]u16, total: u16 };

fn roll_attribute(rand: std.rand.Random) u16 {

var min_roll: u16 = dice;

var total: u16 = 0;

for (0..rolls) |_| {

const roll = rand.uintAtMost(u16, dice - 1) + 1;

if (min_roll > roll) {

min_roll = roll;

}

total += roll;

}

return total - min_roll;

}

fn roll_stats(rand: std.rand.Random) RollResult {

var result: RollResult = RollResult{

.stats = undefined,

.total = 0,

};

var high_stat_count: u16 = 0;

var i: u16 = 0;

while (i < stat_count) {

// roll a stat

result.stats[i] = roll_attribute(rand);

result.total += result.stats[i];

if (result.stats[i] >= high_stat_threshold) high_stat_count += 1;

// find the maximum possible total

const stats_remain = stat_count - i - 1;

const max_possible_total = result.total + dice * (rolls - 1) * stats_remain;

// if it is below the minimum or there are not enough stats over 15 reset

if (max_possible_total < min_stat_sum or high_stat_count + stats_remain < 2) {

i = 0;

result.total = 0;

high_stat_count = 0;

} else {

i += 1;

}

}

return result;

}

pub fn main() !void {

// Create random generator

var prng = std.rand.DefaultPrng.init(blk: {

var seed: u64 = undefined;

try std.os.getrandom(std.mem.asBytes(&seed));

break :blk seed;

});

const rand = prng.random();

const stats = roll_stats(rand);

const stdout = std.io.getStdOut().writer();

try stdout.print("Total: {}\n", .{stats.total});

try stdout.print("Stats: [ ", .{});

for (stats.stats) |stat| {

try stdout.print("{} ", .{stat});

}

try stdout.print("]\n", .{});

}

</syntaxhighlight>

{{out}}

<pre>Total: 79

Stats: [ 14 13 5 16 15 16 ]</pre>