Compiler Explorer

Source code

const std = @import("std");

const Rank = enum {
    two,
    three,
    four,
    five,
    six,
    seven,
    eight,
    nine,
    ten,
    jack,
    queen,
    king,
    ace,

pub const name_table = [@typeInfo(Rank).Enum.fields.len][:0]const u8{
        " 2",
        " 3",
        " 4",
        " 5",
        " 6",
        " 7",
        " 8",
        " 9",
        "10",
        " J",
        " Q",
        " K",
        " A",
    };
};

const Suite = enum {
    club,
    diamond,
    spade,
    heart,

pub const name_table = [@typeInfo(Suite).Enum.fields.len][:0]const u8{
        "♣",
        "♦",
        "♠",
        "♥",
    };
};

const Card = struct {
    suite: Suite,
    rank: Rank,

pub fn print(self: *const Card) void {
        std.debug.print("{s}{s}", .{ Rank.name_table[@intFromEnum(self.*.rank)], Suite.name_table[@intFromEnum(self.*.suite)] });
    }
};

pub fn printCards(cards: []Card) void {
    var count: u64 = 0;
    std.debug.print("[ ", .{});
    for (0..cards.len) |i| {
        cards[i].print();
        if (i < cards.len - 1) std.debug.print(", ", .{});
        count += 1;
        if (count % 10 == 0) std.debug.print("\n  ", .{});
    }
    std.debug.print(" ]\n", .{});
}

const CardDb = struct {
    cards: []Card,
};

const Deck = struct {
    cards: []Card,
    size: usize = 0,

pub fn shuffle(self: *Deck, rand: *const std.Random) !void {
        for (0..self.*.size) |i| {
            const swapWith = rand.uintAtMost(usize, self.*.cards.len - i - 1) + i;
            const tmp = self.*.cards[i];
            self.*.cards[i] = self.*.cards[swapWith];
            self.*.cards[swapWith] = tmp;
        }
    }

pub fn draw(self: *Deck) Card {
        std.debug.assert(self.*.size > 0);

defer self.*.size -= 1;
        return self.*.cards[self.*.size - 1];
    }
};

const Command = struct {
    action: *const fn () anyerror!void,
    name: []const u8,
    description: []const u8,
};

const commands = [_]Command{
    .{ .action = &help, .name = "help", .description = "description for help" },
    .{ .action = &quit, .name = "quit", .description = "description for quit" },
};

var running = true;

pub fn main() !void {
    // var buffer: [@sizeOf(Card) * 52]u8 = undefined;
    // var fba = std.heap.FixedBufferAllocator.init(&buffer);
    // const allocator = fba.allocator();

var input_buffer: [100]u8 = undefined;
    const stdin = std.io.getStdIn().reader();
    const stdout = std.io.getStdOut().writer();

var prng = std.rand.DefaultPrng.init(blk: {
        var seed: u64 = undefined;
        try std.posix.getrandom(std.mem.asBytes(&seed));
        break :blk seed;
    });
    const rng = prng.random();

const card_db = CardDb{ .cards = init: {
        const num_suites = std.meta.fields(Suite).len;
        const num_ranks = std.meta.fields(Rank).len;
        const num_cards = num_suites * num_ranks;
        var cards: [num_cards]Card = undefined;

var i: usize = 0;
        for (0..num_suites) |suite| {
            for (0..num_ranks) |rank| {
                cards[i].suite = @enumFromInt(suite);
                cards[i].rank = @enumFromInt(rank);
                i += 1;
            }
        }

break :init &cards;
    } };

var deck = Deck{
        .cards = card_db.cards,
        .size = card_db.cards.len,
    };
    try deck.shuffle(&rng);

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

while (running) {
        try stdout.print("> ", .{});

_ = try stdin.readUntilDelimiter(&input_buffer, '\n');
        const input: []u8 = std.mem.sliceTo(&input_buffer, '\n');

for (commands) |command| {
            _ = command;
        }

try stdout.print("Invalid command: '{s}'\n", .{input});
    }
}

pub fn help() !void {
    try std.io.getStdOut().writer().print("HELP:\n", .{});
    for (&commands) |*cmd| {
        try std.io.getStdOut().writer().print("{s: 10<}{s}\n", .{ cmd.name, cmd.description });
    }
}

pub fn quit() !void {
    running = false;
}

// test "all cards appear exactly once after shuffle" {
//     const allocator = std.testing.allocator;
//     var prng = std.rand.DefaultPrng.init(blk: {
//         var seed: u64 = undefined;
//         try std.posix.getrandom(std.mem.asBytes(&seed));
//         break :blk seed;
//     });
//     const rng = prng.random();
//
//     var card_db = CardDb{ .cards = undefined };
//     try card_db.init(&allocator);
//     defer card_db.deinit(&allocator);
//
//     var deck = Deck{
//         .cards = card_db.cards,
//         .size = card_db.cards.len,
//     };
//
//     try deck.shuffle(&rng);
//
//     for (0..card_db.cards.len) |i| {
//         var count: u64 = 0;
//         for (0..card_db.cards.len) |j| {
//             if (i == j) continue;
//             if (card_db.cards[i].rank == card_db.cards[j].rank and card_db.cards[i].suite == card_db.cards[j].suite) count += 1;
//         }
//         try std.testing.expect(count == 0);
//     }
// }