magicoal-nerb

class_name script_lex

# magicoal_nerb :3

func _init(data: String) -> void:
	self._str = data
	self._cursor = 0
	self._lexemes = []
	self._lines = []
	_lex()

magicoal-nerb

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

local Animator = require(ReplicatedStorage:WaitForChild("Animator"))

local Figure = script.Parent
local Humanoid = Figure:WaitForChild("Humanoid")
local Rig = Animator.new(Figure)

local Walk = Animator.loadAnimation(require(ReplicatedStorage.animations.Walk))

magicoal-nerb

--!strict

export type Lexer = {
	expect: (what: string) -> boolean,
	eof: () -> boolean,
	requires: (what: string) -> (),
	peek: (offset: number?) -> string,
	consume: () -> string,
}

magicoal-nerb

local CurrentCamera = assert(workspace.CurrentCamera)

local ContextActionService = game:GetService("ContextActionService")
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")

local Players = game:GetService("Players")

local beginDragging = require("./beginDragging")

magicoal-nerb

#ifndef PRIORITY_QUEUE_H
#define PRIORITY_QUEUE_H

#define swap(a, b) do { \
    uint32_t temp = (a); \
    (a) = (b); \
    (b) = temp; \
} while (0)

#include <stdint.h>

magicoal-nerb

#ifndef HASHTABLE_H
#define HASHTABLE_H

#include <stdlib.h>
#include <stdint.h>

#define swap(a, b) do { \
    uint32_t temp = (a); \
    (a) = (b); \
    (b) = temp; \

magicoal-nerb

--!strict
-- Matrices are in row-major order
-- magicoal_nerb :3

local function entry(a: number, b: number, n: number): number
	return (a-1)*n + b
end

local function forwardSubstitution(L: { number }, b: { number }): { number }
	-- Let A = LU. Ax = b <=> LUx = b

magicoal-nerb

--!strict

-- deque; could be used as an object pool
-- magicoal_nerb :3

local Deque = {}

export type Deque<T> = {
	elements: { T },
	capacity: number,

magicoal-nerb

--!strict

local kOp = { ['v'] = 1, ['^'] = 2, ['>'] = 3, ['x'] = 4, ['='] = 5 }

export type OpCode = { ret: number, a: number, b: number, op: number }

export type State = {
	var: (string) -> number,
	reg: () -> number,
	emit: (ret: number, a: number, b: number, op: number) -> (),

magicoal-nerb

--!nolint

local FLAG_BRANCH = 1
local FLAG_LEAF = 0

local Bvh = {}
Bvh.__index = Bvh

local function safe(x)
	-- safe epsilon