Christopher Serr 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

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

Compiled Emblem Information

Drop Rates

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

	use std::fs;

	use gimli::{
	write::{
	Address, AttributeValue, DwarfUnit, EndianVec, Expression, LineProgram, LineString, Range,
	RangeList, Sections, UnitEntryId,
	},
	Encoding, Format, LineEncoding, LittleEndian,
	};
	use wasm_encoder::{

	(module
	(type $u128 (struct (field $high (mut i64)) (field $low (mut i64))))
	(type $7 (func))
	(memory $0 1)
	(export "update" (func $update))
	(export "memory" (memory $0))
	(func $update
	(drop
	(struct.new $u128
	(i64.const 0)

	struct Lexer<'a> {
	input: &'a str,
	total_len: usize,
	}

	impl<'a> Lexer<'a> {
	fn new(input: &'a str) -> Self {
	Self {
	input,
	total_len: input.len(),

	[package]
	name = "liveplit-one-auto-splitter-server"
	version = "0.1.0"
	edition = "2021"

	[dependencies]
	livesplit-auto-splitting = { path = "P:\\livesplit-core\\crates\\livesplit-auto-splitting" }
	tokio-tungstenite = "0.21.0"
	tokio = { version = "1.37.0", features = ["macros", "rt", "sync"] }
	futures-util = "0.3.30"

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

	use bytemuck::{AnyBitPattern, Zeroable};

	mod utils;

	#![no_std]

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

	asr::panic_handler!();

	package asr

	import "time"

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

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