cluaupp 1.0.0 → 1.4.0

package/include/clpp/libs/arrayindexer.clh

@@ -0,0 +1,12 @@
+#pragma once
+
+// ArrayIndexer — dense reusable ECS ids. Acquire pops a free slot; Release swap-removes.
+
+struct ArrayIndexer {
+	int Next;
+	static ArrayIndexer New();
+	int Acquire();
+	void Release(int id);
+	bool Has(int id);
+	LuaArray<int> Living();
+};

package/include/clpp/libs/axiom.clh

@@ -0,0 +1,154 @@
+#pragma once
+
+// Axiom — combat / camera / HUD math. Every function returns a concrete type.
+// Groups: Scalar Lerp Vector CFrame Easing Bezier Geometry Trig Probability Noise Color
+// .axiom schema calls Axiom.Select({ "Scalar", "Lerp" }) from generated Luau.
+
+namespace Axiom {
+	double Clamp(double value, double min, double max);
+	double Map(double value, double inMin, double inMax, double outMin, double outMax);
+	double Wrap(double value, double min, double max);
+	double Sign(double value);
+	double Round(double value);
+	double Round(double value, int digits);
+	double Snap(double value, double step);
+	double PingPong(double t, double length);
+	double Saturate(double value);
+	double Fract(double value);
+	double InvLerp(double from, double to, double value);
+	double Approach(double current, double target, double maxDelta);
+	bool IsFinite(double value);
+	double Abs(double value);
+	double Min(double a, double b);
+	double Max(double a, double b);
+	double Pow(double base, double exp);
+	double Sqrt(double value);
+	double Cbrt(double value);
+	double Hypot(double a, double b);
+	double Log(double value);
+	double Exp(double value);
+	double Smoothstep(double edge0, double edge1, double x);
+	double Smootherstep(double edge0, double edge1, double x);
+	double Gcd(double a, double b);
+	double Lcm(double a, double b);
+	bool IsEven(double value);
+	bool IsOdd(double value);
+	double Factorial(double n);
+	double Scale(double value, int index);
+
+	double Lerp(double from, double to, double alpha);
+	double LerpClamped(double from, double to, double alpha);
+	Vector2 LerpVector2(Vector2 from, Vector2 to, double alpha);
+	Vector3 LerpVector3(Vector3 from, Vector3 to, double alpha);
+	Vector3 LerpVector(Vector3 from, Vector3 to, double alpha);
+	Color3 LerpColor3(Color3 from, Color3 to, double alpha);
+	CFrame LerpCFrame(CFrame from, CFrame to, double alpha);
+	UDim2 LerpUDim2(UDim2 from, UDim2 to, double alpha);
+	double LerpAngle(double from, double to, double alpha);
+	double Inverse(double from, double to, double value);
+
+	Vector3 Project(Vector3 a, Vector3 b);
+	Vector3 Reject(Vector3 a, Vector3 b);
+	Vector3 Reflect(Vector3 incident, Vector3 normal);
+	double Angle(Vector3 a, Vector3 b);
+	double Distance(Vector3 a, Vector3 b);
+	double Distance2(Vector2 a, Vector2 b);
+	CFrame Orthonormal(Vector3 forward);
+	CFrame Orthonormal(Vector3 forward, Vector3 up);
+	Vector3 Slerp(Vector3 a, Vector3 b, double t);
+	CFrame SlerpCFrame(CFrame a, CFrame b, double t);
+	CFrame LookAt(Vector3 from, Vector3 look);
+	CFrame Flat(CFrame cf);
+
+	double InSine(double t);
+	double OutSine(double t);
+	double InOutSine(double t);
+	double InQuad(double t);
+	double OutQuad(double t);
+	double InOutQuad(double t);
+	double InCubic(double t);
+	double OutCubic(double t);
+	double InOutCubic(double t);
+	double InQuart(double t);
+	double OutQuart(double t);
+	double InOutQuart(double t);
+	double InQuint(double t);
+	double OutQuint(double t);
+	double InOutQuint(double t);
+	double InExpo(double t);
+	double OutExpo(double t);
+	double InOutExpo(double t);
+	double InCirc(double t);
+	double OutCirc(double t);
+	double InOutCirc(double t);
+	double InBack(double t);
+	double OutBack(double t);
+	double InOutBack(double t);
+	double InElastic(double t);
+	double OutElastic(double t);
+	double InOutElastic(double t);
+	double InBounce(double t);
+	double OutBounce(double t);
+	double InOutBounce(double t);
+	double Linear(double t);
+
+	Vector3 CubicBezier(double t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3);
+	Vector3 QuadraticBezier(double t, Vector3 p0, Vector3 p1, Vector3 p2);
+	CFrame Hover(double elapsed, Vector3 anchor, Vector3 look);
+	CFrame Float(double elapsed, Vector3 anchor, Vector3 look);
+	CFrame FloatSpin(double elapsed, CFrame anchor);
+
+	bool AabbContains(Vector3 point, Vector3 min, Vector3 max);
+	bool SphereContains(Vector3 point, Vector3 center, double radius);
+	Vector3 RayPlane(Vector3 origin, Vector3 dir, Vector3 point, Vector3 normal);
+	Vector3 Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c);
+	Vector3 ClosestPointOnSegment(Vector3 p, Vector3 a, Vector3 b);
+
+	double Deg(double rad);
+	double Rad(double deg);
+	double DeltaAngle(double from, double to);
+	double AngleDiff(double from, double to);
+	double DeltaAngleDegrees(double from, double to);
+	double NormalizeAngle(double angle);
+	double Sin(double x);
+	double Cos(double x);
+	double Tan(double x);
+	double Asin(double x);
+	double Acos(double x);
+	double Atan2(double y, double x);
+
+	double RandomRange(double min, double max);
+	double Random(double min, double max);
+	int Weighted(LuaArray<double> weights);
+	double Gaussian();
+	double Gaussian(double mean, double std);
+	double Average(LuaArray<double> values);
+	double Sum(LuaArray<double> values);
+
+	double HashU32(double n);
+	double Value1(double x);
+	double Value2(double x, double y);
+	double Value3(double x, double y, double z);
+
+	Color3 FromHSV(double h, double s, double v);
+	Color3 Contrast(Color3 color, double amount);
+	Color3 LerpHSV(Color3 a, Color3 b, double t);
+}
+
+namespace MathUtils {
+	double Lerp(double a, double b, double alpha);
+	double Map(double value, double inMin, double inMax, double outMin, double outMax);
+	double Clamp(double value, double min, double max);
+	double Round(double value);
+	double Round(double value, int digits);
+	double Snap(double value, double step);
+	double Sign(double value);
+	double Wrap(double value, double min, double max);
+	double Saturate(double value);
+	double Inverse(double from, double to, double value);
+	double AngleDiff(double a, double b);
+	double LerpAngle(double a, double b, double alpha);
+	double Random(double min, double max);
+	int Weighted(LuaArray<double> weights);
+	Vector3 LerpVector(Vector3 a, Vector3 b, double alpha);
+}

package/include/clpp/libs/bloom.clh

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <clpp/libs/stage.clh>
+
+struct BloomHandle {
+	GuiObject Instance;
+	void Pause();
+	void Resume();
+	void Destroy();
+};
+
+struct BloomOptions {
+	double Speed;
+	double Size;
+	ColorSequence Gradient;
+	NumberSequence Transparency;
+};
+
+namespace Bloom {
+	const string Shine = "Shine";
+	const string Rainbow = "Rainbow";
+	const string ChromeStroke = "ChromeStroke";
+	const string Grow = "Grow";
+	const string Lift = "Lift";
+	const string Bounce = "Bounce";
+	const string Shrink = "Shrink";
+	const string Punch = "Punch";
+	ColorSequenceKeypoint Stop(double t, Color3 color);
+	ColorSequence Gradient();
+	BloomHandle Play(GuiObject target, string preset);
+	BloomHandle Play(GuiObject target, string preset, BloomOptions options);
+	void Fade(GuiObject element, bool show);
+	void Fade(GuiObject element, bool show, double speed);
+	void Slide(GuiObject element, bool show);
+	void Slide(GuiObject element, bool show, double speed);
+	void Zoom(GuiObject element, bool show);
+	void Zoom(GuiObject element, bool show, double speed);
+	void Bounce(GuiObject element);
+	void Bounce(GuiObject element, double speed);
+	void Hover(GuiObject element);
+	void Hover(GuiObject element, string kind);
+	void Press(GuiObject element);
+	void Press(GuiObject element, string kind);
+	void Ripple(GuiObject element);
+	void Tilt(GuiObject element);
+	void Tilt(GuiObject element, double degrees);
+	void Depth(GuiObject element);
+	void Flip(GuiObject element);
+	void Flip(GuiObject element, double speed);
+	Stage Viewport(GuiObject frame, Instance model);
+	void Type(Frame container, TextLabel label, string text);
+	void Sequence();
+	void FrameSlide(GuiObject element, bool show);
+	void FrameZoom(GuiObject element, bool show);
+	void FrameBounce(GuiObject element);
+	void SetButtonStyle(GuiObject element);
+	void ShowText(Frame container, TextLabel label, string text);
+}

package/include/clpp/libs/coil.clh

@@ -0,0 +1,37 @@
+#pragma once
+
+// Coil — Fraktality damped spring. Frequency is Hz (not rad/s).
+// Gleam.Spring: Coil.new, :Set, :Get, :Step.
+// Coil.new also accepts Vector3 / UDim2 / Color3 (component-wise). Helpers: Coil.Vector / UDim / Color.
+// Step: omega=0 is a no-op; dt >= 1s (or decay envelope ~0) snaps to Goal.
+
+struct Coil {
+	double Damping;
+	double Frequency;
+	auto Goal;
+	auto Position;
+	auto Velocity;
+	static Coil New(double dampingRatio, double frequency, double position);
+	static Coil New(double dampingRatio, double frequency, Vector3 position);
+	static Coil New(double dampingRatio, double frequency, UDim2 position);
+	static Coil New(double dampingRatio, double frequency, Color3 position);
+	static Coil Vector(double dampingRatio, double frequency, Vector3 position);
+	static Coil UDim(double dampingRatio, double frequency, UDim2 position);
+	static Coil UDim2(double dampingRatio, double frequency, UDim2 position);
+	static Coil Color(double dampingRatio, double frequency, Color3 position);
+	void Set(double goal);
+	void Set(Vector3 goal);
+	void Set(UDim2 goal);
+	void Set(Color3 goal);
+	void SetGoal(double target);
+	void SetGoal(Vector3 target);
+	void SetGoal(UDim2 target);
+	void SetGoal(Color3 target);
+	auto Get();
+	void Step(double dt);
+	void Impulse(double velocity);
+	void Impulse(Vector3 velocity);
+	void Impulse(UDim2 velocity);
+	void Impulse(Color3 velocity);
+	auto Update(double dt);
+};

package/include/clpp/libs/crest.clh

@@ -0,0 +1,22 @@
+#pragma once
+
+struct Crest {
+	static Crest new_();
+	Crest setName(string name);
+	Crest setLabel(string text);
+	Crest setImage(string image);
+	Crest setEnabled(bool enabled);
+	Crest setOrder(int order);
+	Crest setWidth(int offset);
+	Crest align(string leftCenterOrRight);
+	Crest setLeft();
+	Crest setMid();
+	Crest setRight();
+	Crest bindEvent(string eventName, func callback);
+	Crest bindToggleItem(GuiObject gui);
+	Crest notify();
+	Crest clearNotices();
+	Crest select();
+	Crest deselect();
+	void Destroy();
+};

package/include/clpp/libs/echo.clh

@@ -0,0 +1,52 @@
+#pragma once
+
+struct EchoEntity {
+	Player Player;
+	CFrame CFrame;
+	double Clock;
+};
+
+struct EchoHolder {
+	EchoEntity Get(Player player);
+	EchoEntity All();
+};
+
+struct EchoEntityLib {
+	EchoEntity new_(Player player);
+};
+
+struct EchoStats {
+	int Packets;
+	int PacketsSent;
+	int PacketsReceived;
+	int BytesSent;
+	int BytesReceived;
+	int Snapshots;
+};
+
+struct EchoConfig {
+	double Rate;
+	double Interpolate;
+	double MaxDistance;
+};
+
+struct EchoRules {
+	bool SkipLocal;
+};
+
+namespace Echo {
+	void Start();
+	EchoHolder Holder();
+	EchoEntityLib Entity();
+	buffer WriteCFrame(CFrame cf);
+	CFrame ReadCFrame(buffer buf);
+	EchoStats Stats();
+	EchoConfig Config();
+	EchoConfig Config(EchoConfig patch);
+	EchoRules ReplicationRules();
+	EchoRules ReplicationRules(EchoRules patch);
+	Folder Events();
+	auto Snapshots();
+	double ServerClock();
+	Player Player();
+}

package/include/clpp/libs/ember.clh

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace Ember {
+	void Emit(Instance root);
+	void Emit(Instance root, int count);
+	void Play(Instance effect);
+	void Stop(Instance effect);
+	Instance CloneOnto(Instance template_, Instance parent);
+	Instance Attach(Instance template_, Instance character);
+	Instance Attach(Instance template_, Instance character, string attachmentName);
+	void Scale(Instance root, double factor);
+	void DestroyAfter(Instance root);
+	void DestroyAfter(Instance root, double lifetime);
+	Instance Burst(Instance template_, Instance parent);
+	Instance Burst(Instance template_, Instance parent, int count);
+	Instance Burst(Instance template_, Instance parent, int count, double lifetime);
+}

package/include/clpp/libs/flare.clh

@@ -0,0 +1,65 @@
+#pragma once
+
+// Flare — Cluaupp networker (Zap-tight generated packing, QuickNet buffers, ByteNet packets/queries).
+// You do not open remotes. Write src/shared/Net.flare; cluaupp build generates Net.clh + Net.luau.
+//
+// packet Hit(Player target, i32 damage) from Client
+// query GetCoins() -> i32
+//
+// Then: Net.Hit.FireServer(target, 25);  Net.GetCoins.Invoke();
+//
+// This header is the kernel write/read API used by generated Net.luau (Flare.writeu8, Flare.readInstance, …).
+// Per-schema packet/query structs come from emitFlareHeader (Net.clh), not from here.
+
+struct FlareCursor {};
+
+struct FlareSession {
+	auto packet(auto spec);
+	auto query(auto spec);
+};
+
+namespace Flare {
+	FlareCursor cursor();
+	FlareCursor cursor(int size);
+	FlareSession open(Instance host);
+
+	void writeu8(FlareCursor cursor, int value);
+	void writeu16(FlareCursor cursor, int value);
+	void writeu32(FlareCursor cursor, int value);
+	void writei8(FlareCursor cursor, int value);
+	void writei16(FlareCursor cursor, int value);
+	void writei32(FlareCursor cursor, int value);
+	void writef32(FlareCursor cursor, double value);
+	void writef64(FlareCursor cursor, double value);
+	void writebool(FlareCursor cursor, bool value);
+	void writestring(FlareCursor cursor, string value);
+	void writeVector3(FlareCursor cursor, Vector3 value);
+	void writeVector2(FlareCursor cursor, Vector2 value);
+	void writeCFrame(FlareCursor cursor, CFrame value);
+	void writeColor3(FlareCursor cursor, Color3 value);
+	void writeUDim(FlareCursor cursor, UDim value);
+	void writeUDim2(FlareCursor cursor, UDim2 value);
+	void writeBrickColor(FlareCursor cursor, BrickColor value);
+	void writebuffer(FlareCursor cursor, buffer value);
+	void writeInstance(FlareCursor cursor, Instance value);
+
+	int readu8(FlareCursor cursor);
+	int readu16(FlareCursor cursor);
+	int readu32(FlareCursor cursor);
+	int readi8(FlareCursor cursor);
+	int readi16(FlareCursor cursor);
+	int readi32(FlareCursor cursor);
+	double readf32(FlareCursor cursor);
+	double readf64(FlareCursor cursor);
+	bool readbool(FlareCursor cursor);
+	string readstring(FlareCursor cursor);
+	Vector3 readVector3(FlareCursor cursor);
+	Vector2 readVector2(FlareCursor cursor);
+	CFrame readCFrame(FlareCursor cursor);
+	Color3 readColor3(FlareCursor cursor);
+	UDim readUDim(FlareCursor cursor);
+	UDim2 readUDim2(FlareCursor cursor);
+	BrickColor readBrickColor(FlareCursor cursor);
+	buffer readbuffer(FlareCursor cursor);
+	Instance readInstance(FlareCursor cursor);
+}

package/include/clpp/libs/gleam.clh

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <clpp/libs/sweep.clh>
+
+struct GleamSource {
+	auto Get();
+	void Set(auto value);
+	void Listen(func fn);
+};
+
+struct GleamAction {};
+
+struct GleamProps {
+	LuaArray<Instance> Children;
+	Instance Parent;
+	string Name;
+	string Text;
+	string PlaceholderText;
+	string Image;
+	bool Visible;
+	bool Active;
+	bool Selectable;
+	bool TextScaled;
+	bool TextWrapped;
+	bool RichText;
+	bool AutoButtonColor;
+	bool ClipsDescendants;
+	bool IgnoreGuiInset;
+	bool ResetOnSpawn;
+	bool Enabled;
+	bool Modal;
+	int ZIndex;
+	int LayoutOrder;
+	int BorderSizePixel;
+	int DisplayOrder;
+	double TextSize;
+	double Rotation;
+	double BackgroundTransparency;
+	double ImageTransparency;
+	double ScrollBarThickness;
+	Vector2 AnchorPoint;
+	UDim2 Size;
+	UDim2 Position;
+	Color3 TextColor3;
+	Color3 BackgroundColor3;
+	Color3 BorderColor3;
+	Color3 ImageColor3;
+	Font FontFace;
+	func Activated;
+	func MouseButton1Click;
+	func MouseButton2Click;
+	func MouseButton1Down;
+	func MouseButton1Up;
+	func MouseEnter;
+	func MouseLeave;
+	func InputBegan;
+	func InputEnded;
+	func AncestryChanged;
+	func Changed;
+	func Focused;
+	func FocusLost;
+};
+
+struct GleamApply {
+	Instance Apply(GleamProps props);
+};
+
+namespace Gleam {
+	GleamSource Source(auto initial);
+	GleamSource Derive(func compute);
+	void Effect(func fn);
+	auto Untrack(func fn);
+	void Batch(func fn);
+	void Cleanup(func fn);
+
+	Instance Create(string className);
+	Instance Create(string className, GleamProps props);
+	TextButton TextButton();
+	TextButton TextButton(GleamProps props);
+	TextLabel TextLabel();
+	TextLabel TextLabel(GleamProps props);
+	Frame Frame();
+	Frame Frame(GleamProps props);
+	ScreenGui ScreenGui();
+	ScreenGui ScreenGui(GleamProps props);
+	ImageLabel ImageLabel();
+	ImageLabel ImageLabel(GleamProps props);
+	ScrollingFrame ScrollingFrame();
+	ScrollingFrame ScrollingFrame(GleamProps props);
+
+	LuaArray<Instance> List();
+	LuaArray<Instance> List(Instance a);
+	LuaArray<Instance> List(Instance a, Instance b);
+	LuaArray<Instance> List(Instance a, Instance b, Instance c);
+
+	func Mount(Instance instance, Instance parent);
+	func Root(func fn);
+
+	GleamSource Show(GleamSource source, func render);
+	GleamSource Switch(GleamSource source, auto map);
+	GleamSource Indexes(GleamSource source, func render);
+	GleamSource Values(GleamSource source, func render);
+
+	GleamSource Spring(GleamSource source);
+	GleamSource Spring(GleamSource source, double speed);
+	GleamSource Spring(GleamSource source, double speed, double damping);
+
+	GleamAction Action(func fn);
+	GleamApply Apply(Instance instance);
+	Instance Apply(Instance instance, GleamProps props);
+}

package/include/clpp/libs/guide.clh

@@ -0,0 +1,42 @@
+#pragma once
+#include <clpp/libs/sweep.clh>
+
+struct GuideStep {
+	void Enter(Sweep sweep);
+	void Exit();
+	Instance Highlight;
+};
+
+struct GuideConfig {
+	func Render;
+	func Highlight;
+	func OnStep;
+	func OnComplete;
+};
+
+struct GuideSession {
+	void Start();
+	void Start(int step);
+	bool GoTo(int step);
+	bool Advance();
+	bool Back();
+	void Complete();
+	int GetStep();
+	bool IsActive();
+	void Destroy();
+};
+
+struct GuideSteps {
+	static GuideStep new_(int order);
+	static GuideStep new_(func enter);
+	static GuideStep new_(int order, GuideStep spec);
+};
+
+namespace Guide {
+	GuideSteps Step;
+	GuideSession build(LuaArray<GuideStep> steps);
+	GuideSession build(LuaArray<GuideStep> steps, GuideConfig config);
+	GuideSession Start();
+	GuideSession Start(LuaArray<GuideStep> steps);
+	GuideSession Start(LuaArray<GuideStep> steps, GuideConfig config);
+}

package/include/clpp/libs/helm.clh

@@ -0,0 +1,31 @@
+#pragma once
+
+struct HelmCommand {
+	string Name;
+	string Permission;
+	func Callback;
+};
+
+struct HelmRegistry {};
+struct HelmDispatcher {};
+struct HelmType {};
+
+struct HelmSession {
+	Player Player;
+	bool Run(string name);
+	bool Run(string name, auto a);
+	bool Run(string name, auto a, auto b);
+	bool Run(string name, auto a, auto b, auto c);
+};
+
+namespace Helm {
+	void RegisterDefaultCommands();
+	void RegisterHook(string name, func callback);
+	void RegisterType(string name, HelmType typeDefinition);
+	void RegisterCommand(HelmCommand commandDefinition);
+	HelmRegistry Registry();
+	HelmDispatcher Dispatcher();
+	void Give(Player player, Player target, int amount);
+	void Kick(Player player, Player target, string reason);
+	HelmSession Open(Player player);
+}

package/include/clpp/libs/hive.clh

@@ -0,0 +1,20 @@
+#pragma once
+
+struct HiveWorld {
+	int Entity();
+	void Set(int entity, int componentId, auto value);
+	auto Get(int entity, int componentId);
+	void Remove(int entity, int componentId);
+	void Despawn(int entity);
+	bool Has(int entity, int componentId);
+	auto Query();
+	buffer Snapshot(int componentId);
+};
+
+namespace Hive {
+	HiveWorld World();
+	HiveWorld World(auto schema);
+	HiveWorld World(auto schema, bool authoritative);
+	HiveWorld AuthoritativeWorld();
+	HiveWorld AuthoritativeWorld(auto schema);
+}