cluaupp 0.2.3 → 1.3.0

package/templates/game/include/clpp/libs/chrono.clh

@@ -0,0 +1,26 @@
+#pragma once
+
+// Parihsz/Chrono — custom character replication, vendored into CluauppLibs.Chrono
+struct ChronoHolder {};
+struct ChronoEntity {};
+struct ChronoStats {};
+struct ChronoConfig {};
+struct ChronoReplicationRules {};
+struct ChronoEvents {};
+struct ChronoSnapshots {};
+struct ChronoServerClock {};
+struct ChronoPlayer {};
+
+namespace Chrono {
+	void Start();
+	void Start(ModuleScript config);
+	ChronoHolder Holder();
+	ChronoEntity Entity();
+	ChronoStats Stats();
+	ChronoConfig Config();
+	ChronoReplicationRules ReplicationRules();
+	ChronoEvents Events();
+	ChronoSnapshots Snapshots();
+	ChronoServerClock ServerClock();
+	ChronoPlayer Player();
+}

package/templates/game/include/clpp/libs/cmdr.clh

@@ -0,0 +1,16 @@
+#pragma once
+
+// evaera/Cmdr — vendored into CluauppLibs.Cmdr (server). Client: Cmdr.CmdrClient
+struct CmdrType {};
+struct CmdrCommand {};
+struct CmdrRegistry {};
+struct CmdrDispatcher {};
+
+namespace Cmdr {
+	void RegisterDefaultCommands();
+	void RegisterHook(string name, void (*callback)());
+	void RegisterType(string name, CmdrType typeDefinition);
+	void RegisterCommand(CmdrCommand commandDefinition);
+	CmdrRegistry Registry();
+	CmdrDispatcher Dispatcher();
+}

package/templates/game/include/clpp/libs/dataservice.clh

@@ -0,0 +1,138 @@
+#pragma once
+
+// KartzRbx/DataServiceV2 — https://github.com/KartzRbx/DataServiceV2
+// Runtime: CluauppLibs.DataService
+//
+// Real surface:
+//   DataService:Server / DataService:Client / DataService:Paths / DataService:Enum
+
+struct DataPath {};
+struct DataProfile {};
+
+struct DataBufferStats {
+	double Bytes;
+	double Messages;
+	double LastPacketBytes;
+	double LastUtilization;
+};
+
+struct OrderedListOptions {
+	string key;
+	string order;
+	int limit;
+};
+
+struct DataOrderList {
+	string Asc;
+	string Desc;
+};
+
+struct DataServiceEnum {
+	DataOrderList OrderList;
+};
+
+template <typename T>
+struct DataServiceOptions {
+	T Template;
+	string StoreName;
+	bool UseMock;
+	string KeyPrefix;
+	LuaArray<DataPath> Exclude;
+	bool StrictPaths;
+	bool AutoCreateMissingTables;
+};
+
+struct Data {
+	RBXScriptSignal Changed;
+	bool Destroyed;
+
+	template <typename T>
+	T Get();
+	template <typename T>
+	T Get(DataPath path);
+
+	template <typename T>
+	T GetPersisted();
+	template <typename T>
+	T GetPersisted(DataPath path);
+
+	template <typename T>
+	T GetTransient();
+	template <typename T>
+	T GetTransient(DataPath path);
+
+	bool HasTransient();
+	bool HasTransient(DataPath path);
+
+	template <typename T>
+	void Set(DataPath path, T value);
+	template <typename T>
+	void SetTransient(DataPath path, T value);
+
+	template <typename T>
+	T Update(DataPath path, T (*fn)(T current));
+	template <typename T>
+	T UpdateTransient(DataPath path, T (*fn)(T current));
+
+	void ClearTransient();
+	void ClearTransient(DataPath path);
+
+	template <typename T>
+	void ArrayInsert(DataPath path, T value);
+	template <typename T>
+	void ArrayInsert(DataPath path, T value, int index);
+	template <typename T>
+	void ArrayInsertTransient(DataPath path, T value);
+	template <typename T>
+	void ArrayInsertTransient(DataPath path, T value, int index);
+
+	template <typename T>
+	T ArrayRemove(DataPath path, int index);
+	template <typename T>
+	T ArrayRemoveTransient(DataPath path, int index);
+
+	template <typename V>
+	LuaArray<V> GetOrderedList(DataPath path, OrderedListOptions options);
+	template <typename V>
+	LuaArray<V> GetOrderedListWithPriority(DataPath path, string key);
+	template <typename V>
+	LuaArray<V> GetOrderedListWithPriority(DataPath path, string key, string order);
+
+	RBXScriptSignal GetChangedSignal(DataPath path);
+	RBXScriptSignal GetPathChangedSignal(DataPath path);
+	RBXScriptSignal GetIndexChangedSignal(DataPath path);
+	RBXScriptSignal GetArrayInsertedSignal(DataPath path);
+	RBXScriptSignal GetArrayRemovedSignal(DataPath path);
+
+	DataPath Typed(DataPath path);
+	void Destroy();
+};
+
+struct DataServiceServer {
+	DataPath Paths;
+	template <typename T>
+	DataServiceServer Init(DataServiceOptions<T> options);
+	Data WaitFor(Player player);
+	Data Get(Player player);
+	bool HasData(Player player);
+	DataProfile GetProfile(Player player);
+	DataBufferStats GetBufferStats();
+	DataBufferStats GetBufferStats(Player player);
+	void Destroy();
+};
+
+struct DataServiceClient {
+	DataPath Paths;
+	Data Init();
+	Data WaitForData();
+	Data Get();
+	DataBufferStats GetBufferStats();
+	void Destroy();
+};
+
+struct DataService {
+	static DataServiceServer Server;
+	static DataServiceClient Client;
+	static DataPath Paths;
+	static DataServiceEnum Enum;
+};

package/templates/game/include/clpp/libs/display.clh

@@ -0,0 +1,12 @@
+#pragma once
+
+// nightcycle/display — pretty-print Luau values (Rust Display-style).
+struct DisplayBuilder {};
+
+namespace Display {
+	DisplayBuilder builder();
+	string display(string value);
+	string display(double value);
+	string display(bool value);
+	string display(Instance value);
+}

package/templates/game/include/clpp/libs/ezvisual.clh

@@ -0,0 +1,16 @@
+#pragma once
+
+// arxkdev/ezVisualz — EasyVisuals, vendored into CluauppLibs.EzVisualz
+struct EzVisualz {
+	static EzVisualz new_(GuiObject target, string effectType);
+	static EzVisualz new_(GuiObject target, string effectType, double speed, double size);
+	void Play();
+	void Pause();
+	void Resume();
+	void Stop();
+	void Destroy();
+	GuiObject UIInstance;
+	double Speed;
+	double Size;
+	bool IsPaused;
+};

package/templates/game/include/clpp/libs/formatnumber.clh

@@ -0,0 +1,14 @@
+#pragma once
+
+// Blockzez/RobloxFormatNumber — vendored into CluauppLibs.FormatNumber
+struct FormatNumberMain {};
+struct FormatNumberSimple {};
+
+namespace FormatNumber {
+	string Abbreviate(double value);
+	string Abbreviate(double value, int digits);
+	string Comma(double value);
+	string Compact(double value);
+	FormatNumberMain Main();
+	FormatNumberSimple Simple();
+}

package/templates/game/include/clpp/libs/fusion.clh

@@ -0,0 +1,41 @@
+#pragma once
+
+// dphfox/Fusion 0.4 — vendored into CluauppLibs.Fusion
+struct FusionScope {};
+struct FusionState {};
+struct FusionKey {};
+struct FusionObserver {};
+struct FusionContextual {};
+
+namespace Fusion {
+	FusionScope scoped();
+	FusionKey New(string className);
+	template <typename T>
+	FusionState Value(T initial);
+	FusionState Computed(void (*callback)());
+	FusionObserver Observer(FusionState value);
+	template <typename T>
+	T peek(FusionState value);
+	FusionKey Hydrate(Instance instance);
+	FusionKey Children();
+	FusionKey Child();
+	FusionKey OnEvent(string eventName);
+	FusionKey OnChange(string propertyName);
+	FusionKey Out(string propertyName);
+	FusionKey Attribute(string name);
+	FusionKey AttributeChange(string name);
+	FusionKey AttributeOut(string name);
+	FusionKey Tag(string name);
+	FusionState Tween(FusionState value, TweenInfo tweenInfo);
+	FusionState Spring(FusionState value, double speed, double damping);
+	FusionState ForKeys(FusionState input, void (*processor)());
+	FusionState ForValues(FusionState input, void (*processor)());
+	FusionState ForPairs(FusionState input, void (*processor)());
+	void doCleanup(Instance task);
+	FusionScope deriveScope(FusionScope scope);
+	FusionScope innerScope(FusionScope scope);
+	void insert(FusionScope scope, Instance task);
+	template <typename T>
+	FusionContextual Contextual(T defaultValue);
+	void Safe(void (*callback)());
+}

package/templates/game/include/clpp/libs/iris.clh

@@ -0,0 +1,40 @@
+#pragma once
+
+// SirMallard/Iris — vendored into CluauppLibs.Iris
+struct IrisWidget {};
+struct IrisState {};
+
+namespace Iris {
+	void Init();
+	void Init(Instance parent);
+	void Shutdown();
+	void Connect(void (*callback)());
+	bool Window(string title);
+	void End();
+	void Text(string text);
+	bool Button(string label);
+	bool SmallButton(string label);
+	bool Checkbox(string label);
+	bool Checkbox(string label, bool* value);
+	IrisWidget InputNum(string label);
+	IrisWidget InputText(string label);
+	IrisWidget SliderNum(string label);
+	IrisWidget DragNum(string label);
+	bool Tree(string label);
+	bool CollapsingHeader(string label);
+	bool Combo(string label);
+	bool RadioButton(string label, bool value);
+	bool TabBar();
+	bool Tab(string label);
+	bool Table(int columns);
+	void SameLine();
+	void Separator();
+	void Indent();
+	void Unindent();
+	template <typename T>
+	IrisState State(T initial);
+	void PushConfig(IrisState style);
+	void PopConfig();
+	void ForceRefresh();
+	void Append(GuiObject instance);
+}

package/templates/game/include/clpp/libs/janitor.clh

@@ -0,0 +1,38 @@
+#pragma once
+
+// howmanysmall/Janitor — vendored into CluauppLibs.Janitor
+struct Janitor {
+	bool CurrentlyCleaning;
+	bool SuppressInstanceReDestroy;
+	bool UnsafeThreadCleanup;
+	Janitor();
+	template <typename T>
+	T Add(T object);
+	template <typename T>
+	T Add(T object, bool callDirectly);
+	template <typename T>
+	T Add(T object, string methodName);
+	template <typename T>
+	T Add(T object, string methodName, string index);
+	template <typename T>
+	T AddObject(T constructor);
+	template <typename P>
+	P AddPromise(P promise);
+	template <typename P>
+	P AddPromise(P promise, string index);
+	Janitor Remove(string index);
+	Janitor RemoveNoClean(string index);
+	Janitor RemoveList(string index);
+	Janitor RemoveListNoClean(string index);
+	template <typename T>
+	T Get(string index);
+	void GetAll();
+	void Cleanup();
+	void Destroy();
+	RBXScriptConnection LinkToInstance(Instance object);
+	RBXScriptConnection LinkToInstance(Instance object, bool allowMultiple);
+	Janitor LinkToInstances(Instance object);
+	static bool Is(Instance value);
+	static bool Is(string value);
+	static bool instanceof(Instance value);
+};

package/templates/game/include/clpp/libs/math.clh

@@ -0,0 +1,14 @@
+#pragma once
+
+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 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/templates/game/include/clpp/libs/module3d.clh

@@ -0,0 +1,23 @@
+#pragma once
+
+// TheNexusAvenger/Module3D — ViewportFrame adorn, vendored into CluauppLibs.Module3D
+struct Model3D {
+	Model Object3D;
+	GuiObject AdornFrame;
+	Camera Camera;
+	bool Visible;
+	void Update();
+	void SetCFrame(CFrame newCF);
+	CFrame GetCFrame();
+	void SetDepthMultiplier(double multiplier);
+	double GetDepthMultiplier();
+	void SetActive(bool active);
+	bool GetActive();
+	void Destroy();
+	void End();
+};
+
+struct Module3D {
+	static Model3D new_(Instance model);
+	static Model3D Attach3D(GuiObject frame, Instance model);
+};

package/templates/game/include/clpp/libs/net.clh

@@ -0,0 +1,40 @@
+#pragma once
+
+// Buffer-packed RemoteEvent / RemoteFunction. Names are unique per game.
+struct NetEvent {
+	void Fire(Player player);
+	template <typename A>
+	void Fire(Player player, A a);
+	template <typename A, typename B>
+	void Fire(Player player, A a, B b);
+	template <typename A, typename B, typename C>
+	void Fire(Player player, A a, B b, C c);
+	void FireAll();
+	template <typename A>
+	void FireAll(A a);
+	template <typename A, typename B>
+	void FireAll(A a, B b);
+	void FireServer();
+	template <typename A>
+	void FireServer(A a);
+	template <typename A, typename B>
+	void FireServer(A a, B b);
+	void On(void (*callback)());
+};
+
+struct NetFunction {
+	void On(void (*callback)());
+	template <typename R>
+	R Invoke(Player player);
+	template <typename R, typename A>
+	R Invoke(Player player, A a);
+	template <typename R>
+	R InvokeServer();
+	template <typename R, typename A>
+	R InvokeServer(A a);
+};
+
+namespace Net {
+	NetEvent Event(string name);
+	NetFunction Function(string name);
+}

package/templates/game/include/clpp/libs/promise.clh

@@ -0,0 +1,28 @@
+#pragma once
+
+// evaera/roblox-lua-promise — vendored into CluauppLibs.Promise
+struct Promise {
+	Promise(void (*executor)());
+	template <typename T>
+	static Promise resolve(T value);
+	static Promise reject(string err);
+	static Promise delay(double seconds);
+	static Promise try_(void (*callback)());
+	static Promise all(LuaArray<Promise> list);
+	static Promise race(LuaArray<Promise> list);
+	static Promise retry(void (*callback)(), int times);
+	Promise Then(void (*ok)());
+	Promise Catch(void (*fail)());
+	Promise Finally(void (*callback)());
+	Promise andThen(void (*ok)());
+	Promise catch_(void (*fail)());
+	Promise finally(void (*callback)());
+	template <typename T>
+	T Await();
+	template <typename T>
+	T await();
+	void Cancel();
+	void cancel();
+	string GetStatus();
+	string getStatus();
+};

package/templates/game/include/clpp/libs/spring.clh

@@ -0,0 +1,17 @@
+#pragma once
+
+// nightcycle/spring — Fraktality-style damped spring, vendored into CluauppLibs.Spring
+struct Spring {
+	double Damping;
+	double Frequency;
+	double Goal;
+	double Position;
+	double Velocity;
+	Spring(double dampingRatio, double frequency, double position);
+	void Set(double goal);
+	double Get();
+	void Step(double dt);
+	void Impulse(double velocity);
+	void SetGoal(double target);
+	double Update(double dt);
+};

package/templates/game/include/clpp/libs/statemachine.clh

@@ -0,0 +1,18 @@
+#pragma once
+
+// Prooheckcp/RobloxStateMachine — vendored into CluauppLibs.StateMachine
+struct StateData {};
+
+struct StateMachine {
+	static StateMachine new_(string initial);
+	static StateData LoadDirectory(Instance directory);
+	void ChangeState(string name);
+	string GetState();
+	string GetCurrentState();
+	string GetPreviousState();
+	StateData GetData();
+	void ChangeData(string index, string value);
+	void ChangeData(string index, double value);
+	void ChangeData(string index, bool value);
+	void Destroy();
+};

package/templates/game/include/clpp/libs/stickybillboard.clh

@@ -0,0 +1,13 @@
+#pragma once
+
+// Cluaupp StickyBillboard — BillboardGui that stays on an adornee.
+struct StickyBillboard {
+	static StickyBillboard new_(Instance adornee, GuiObject gui);
+	void SetText(string text);
+	void SetEnabled(bool enabled);
+	void SetMaxDistance(double distance);
+	void Destroy();
+	Instance Adornee;
+	GuiObject Gui;
+	BillboardGui Billboard;
+};

package/templates/game/include/clpp/libs/topbarplus.clh

@@ -0,0 +1,28 @@
+#pragma once
+
+// 1ForeverHD/TopbarPlus — vendored into CluauppLibs.TopbarPlus (struct Icon)
+struct IconTheme {};
+
+struct Icon {
+	static Icon new_();
+	Icon setName(string name);
+	Icon setLabel(string text);
+	Icon setImage(string image);
+	Icon setEnabled(bool enabled);
+	Icon setOrder(int order);
+	Icon setWidth(int offset);
+	Icon align(string leftCenterOrRight);
+	Icon setLeft();
+	Icon setMid();
+	Icon setRight();
+	Icon bindEvent(string eventName, void (*callback)());
+	Icon bindToggleItem(GuiObject gui);
+	Icon modifyTheme(IconTheme modifications);
+	Icon setTheme(IconTheme theme);
+	Icon notify();
+	Icon clearNotices();
+	Icon select();
+	Icon deselect();
+	Icon autoDeselect(bool enabled);
+	void Destroy();
+};

package/templates/game/include/clpp/libs/twinkle.clh

@@ -0,0 +1,15 @@
+#pragma once
+
+// UI animator. https://devforum.roblox.com/t/twinkle-free-powerful-ui-animator-module/4512304
+namespace Twinkle {
+	void Fade(GuiObject element, bool show);
+	void Fade(GuiObject element, bool show, double speed);
+	void FrameSlide(GuiObject element, bool show);
+	void FrameSlide(GuiObject element, bool show, double speed);
+	void FrameZoom(GuiObject element, bool show);
+	void FrameZoom(GuiObject element, bool show, double speed);
+	void FrameBounce(GuiObject element);
+	void FrameBounce(GuiObject element, double speed);
+	void SetButtonStyle(GuiObject element);
+	void SetButtonStyle(GuiObject element, string hoverType, string pressType, double scalePercent);
+}

package/templates/game/include/clpp/libs/vfx.clh

@@ -0,0 +1,13 @@
+#pragma once
+
+// Cluaupp VfxUtil — emit / play / stop / clone ParticleEmitters, Beams, Trails, Sounds.
+namespace VfxUtil {
+	void Emit(Instance root);
+	void Emit(Instance root, int count);
+	void Play(Instance effect);
+	void Stop(Instance effect);
+	Instance CloneOnto(Instance template_, Instance parent);
+	void Scale(Instance root, double factor);
+	void DestroyAfter(Instance root, double lifetime);
+	Instance Burst(Instance template_, Instance parent);
+}

package/templates/game/include/clpp/libs.clh

@@ -0,0 +1,24 @@
+#pragma once
+// Cluaupp libraries — CL++ IntelliSense. clpp emits
+// require(ReplicatedStorage.CluauppLibs.*). Runtime lives in runtime/.
+
+#include <clpp/generated/instances.clh>
+#include <clpp/libs/janitor.clh>
+#include <clpp/libs/promise.clh>
+#include <clpp/libs/net.clh>
+#include <clpp/libs/math.clh>
+#include <clpp/libs/formatnumber.clh>
+#include <clpp/libs/module3d.clh>
+#include <clpp/libs/twinkle.clh>
+#include <clpp/libs/dataservice.clh>
+#include <clpp/libs/ezvisual.clh>
+#include <clpp/libs/spring.clh>
+#include <clpp/libs/display.clh>
+#include <clpp/libs/stickybillboard.clh>
+#include <clpp/libs/topbarplus.clh>
+#include <clpp/libs/cmdr.clh>
+#include <clpp/libs/chrono.clh>
+#include <clpp/libs/iris.clh>
+#include <clpp/libs/fusion.clh>
+#include <clpp/libs/statemachine.clh>
+#include <clpp/libs/vfx.clh>

package/templates/game/include/clpp/roblox.clh

@@ -0,0 +1,32 @@
+#pragma once
+// Cluaupp — Roblox API stubs for CL++ IntelliSense.
+// Source: official client dump + datatypes from create.roblox.com
+// clpp emits Luau (Vector3.new, Instance.new, :GetPlayers, ...).
+
+#include <clpp/generated/enums.clh>
+#include <clpp/datatypes.clh>
+#include <clpp/generated/instances.clh>
+#include <clpp/libs.clh>
+
+template <typename T>
+T GetService();
+
+template <typename T>
+T GetService(Instance game_);
+
+extern DataModel game;
+extern Workspace workspace;
+extern LuaSourceContainer script;
+
+void post(string message);
+void warn(string message);
+void report(string message);
+string to_string(auto value);
+double to_number(auto value);
+bool to_bool(auto value);
+
+double tick();
+double time();
+void wait(double seconds = 0);
+void spawn(void (*callback)());
+void delay(double seconds, void (*callback)());