CryZe

use std::{
    marker::PhantomData,
    mem,
    ops::{Deref, DerefMut},
    ptr::{self, NonNull},
};

use bytemuck::{AnyBitPattern, Zeroable};

mod utils;

CryZe

#![no_std]

use asr::{
    future::{next_tick, retry},
    signature::Signature,
    timer, Process,
};

asr::panic_handler!();

CryZe

Auto Splitting Runtime Support

Supported languages

Rust

• 👍 Modern language with really good WebAssembly support
• 👍 Great ecosystem where most crates work perfectly fine in WebAssembly
• 👍 Easy project setup
• 👎 Ownership and borrowing make things a little harder

CryZe

package asr

import "time"

type TimerState = uint32
type ProcessId = uint64
type Address = uint64

func decodeString(text string) (*byte, uint) {
	return decodeSlice(([]byte)(text))

CryZe

Notes on Monotonic Clocks

We can't use std's Instant as it's insufficiently specified. It neither guarantees "real time" nor does it guarantee measuring "uptime" (the time the OS has been awake rather than suspended), meaning that you can't actually rely on it in practice. In livesplit-core we definitely want real time rather than uptime. Various operating systems are problematic:

Linux, BSD and other Unixes

CryZe

Compiled Emblem Information

Drop Rates

• Bronze: 88%
• Silver: 10%
• Gold: 2%

Type Stacking (when you have multiple of the same type)

CryZe

#include "asr/asr_helpers.h"
#include "asr/mini_libc.h"

ProcessId process = 0;
Address unity = 0;

uint8_t old_run_active = 0;
uint8_t old_timer_paused = 0;

typedef struct {

CryZe

/**
 * Sets the tick rate of the runtime. This influences the amount of times the
 * `update` function is called per second.
 */
declare function setTickRate(ticksPerSecond: number): void;
/** Prints a log message for debugging purposes. */
declare function printMessage(message: unknown): void;

declare type Address = BigInt;

CryZe

pub trait PopulateString {
    fn populate(self, buf: &mut String);
    fn as_str(&self) -> &str;
    fn into_string(self) -> String {
        let mut buf = String::new();
        self.populate(&mut buf);
        buf
    }
}

CryZe

struct Eversleep {
    time_info: Watcher<TimeInfo>,
}

impl<'a> AutoSplitter<'a> for Eversleep {
    type Data = &'a Pair<TimeInfo>;

    fn unhooked(&mut self) {
        self.time_info.update(None);
    }