mlarouche

So you want to handle save games ?

Most games once reaced a certain size will need to persist data between game sessions. In our game dev jargon, we call this data a Save Game.

Your first reflex would be to think: oh this is easy, we only need to find the user's documents or data folder and use simple file read and write operations to handle the save data.

Assumming we are using the Zig programming language, our favorite here at Cold Bytes Games, and the library known-folders, a naive save game serialization code could look like this (this code has not been tested).

const known_folders = @import("known-folders");

mlarouche

const std = @import("std");
const platform = @import("../platforms/platform.zig").platform;
const GpuResource = @import("gpu_resource.zig").GpuResource;

pub const CommandListKind = enum {
    Graphics,
    Compute,
    Copy,
};

mlarouche

const std = @import("std");
const win32 = @import("win32.zig");
const d3d12 = @import("d3d12.zig");
const dxgi = @import("dxgi1_4.zig");
const d3dcompiler = @import("d3dcompiler.zig");

const windows = std.os.windows;

const L = std.unicode.utf8ToUtf16LeStringLiteral;

mlarouche

{
    "os": "windows",
    "libraries": [
        "c",
        "d3d12",
        "dxgi",
        "d3dcompiler",
        "dxguid"
    ],
    "include_dirs": [],

mlarouche

const DxContext = struct {
    device: ?*dx.ID3D11Device = null,
    deviceContext: ?*dx.ID3D11DeviceContext = null,
    swapChain: ?*dx.IDXGISwapChain = null,
    mainRenderTargetView: ?*dx.ID3D11RenderTargetView = null,
};

var dxContext: DxContext = undefined;

mlarouche

; ModuleID = 'test'
source_filename = "test"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%"[]u8" = type { i8*, i64 }
%std.builtin.StackTrace = type { i64, %"[]usize" }
%"[]usize" = type { i64*, i64 }
%std.target.LinuxVersionRange = type { %std.builtin.Range, %std.builtin.Version }
%std.builtin.Range = type { %std.builtin.Version, %std.builtin.Version }

mlarouche

fn findImageFormat(inStream: *ImageInStream, seekStream: *ImageSeekStream) !ImageFormat {
        const allFuncs = comptime blk: {
                // TODO: Use ArrayList when Zig support compile-time allocator
                var result:[16]fn(inStream: *ImageInStream, seekStream: *ImageSeekStream) anyerror!ImageFormat = undefined;
                var index:usize = 0;
                inline for (std.meta.declarations(AllImageFormats)) |decl| {
                switch(decl.data) {
                    .Type => |entryType| {
                        const entryTypeInfo = @typeInfo(entryType);
                        if (entryTypeInfo== .Struct) {

mlarouche

fn comFindReturnType(comptime vTableType: type, comptime name: []const u8) type {
    for (@typeInfo(vTableType).Struct.fields) |field| {
        if (std.mem.eql(u8, field.name, name)) {
            const funcType = @typeInfo(@typeInfo(field.field_type).Optional.child);
            return funcType.Fn.return_type.?;
        }
    }
    return void;
}

mlarouche

usingnamespace @import("std").os.windows;

extern "user32" fn MessageBoxA(hWnd: ?HANDLE, lpText: ?LPCTSTR, lpCaption: ?LPCTSTR, uType: UINT) callconv(.Stdcall) c_int;

pub export fn WinMain(hInstance: ?HINSTANCE, hPrevInstance: ?HINSTANCE, lpCmdLine: ?LPWSTR, nShowCmd: INT) callconv(.Stdcall) INT {
    _ = MessageBoxA(null, "Zig is pretty great!", "Wow much exposure", 4);

    return 0;
}

mlarouche

fixed=2048
fixed2=640
result=3.51 / 819