cluaupp 0.1.0

package/include/cluaupp/libs/chrono.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+// Parihsz/Chrono — custom character replication, vendored into CluauppLibs.Chrono
+class ChronoHolder {};
+class ChronoEntity {};
+class ChronoStats {};
+class ChronoConfig {};
+class ChronoReplicationRules {};
+class ChronoEvents {};
+class ChronoSnapshots {};
+class ChronoServerClock {};
+class 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/include/cluaupp/libs/cmdr.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+// evaera/Cmdr — vendored into CluauppLibs.Cmdr (server). Client: Cmdr.CmdrClient
+class CmdrType {};
+class CmdrCommand {};
+class CmdrRegistry {};
+class 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/include/cluaupp/libs/dataservice.hpp

@@ -0,0 +1,141 @@
+#pragma once
+
+// KartzRbx/DataServiceV2 — https://github.com/KartzRbx/DataServiceV2
+// Runtime: CluauppLibs.DataService
+//
+// Real surface (not Get(player, path)):
+//   DataService.Server / DataService.Client / DataService.Paths / DataService.Enum
+//   local data = Server:WaitFor(player)
+//   data:Get(Paths.Currencies.Coins)
+//   data:GetChangedSignal(path):Connect(function(newValue, oldValue) end)
+
+class DataPath {};
+class 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;
+};
+
+struct DataServiceOptions {
+	string StoreName;
+	bool UseMock;
+	string KeyPrefix;
+	bool StrictPaths;
+	bool AutoCreateMissingTables;
+};
+
+class Data {
+public:
+	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();
+};
+
+class DataServiceServer {
+public:
+	DataPath Paths;
+	DataServiceServer* Init(DataServiceOptions 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();
+};
+
+class DataServiceClient {
+public:
+	DataPath Paths;
+	Data* Init();
+	Data* WaitForData();
+	Data* Get();
+	DataBufferStats* GetBufferStats();
+	void Destroy();
+};
+
+class DataService {
+public:
+	static DataServiceServer Server;
+	static DataServiceClient Client;
+	static DataPath Paths;
+	static DataServiceEnum Enum;
+};

package/include/cluaupp/libs/display.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+// nightcycle/display — pretty-print Luau values (Rust Display-style).
+// Vendored into CluauppLibs.Display with nightcycle/option bundled.
+class DisplayBuilder {};
+
+namespace Display {
+	DisplayBuilder* builder();
+	string display(string value);
+	string display(double value);
+	string display(bool value);
+	string display(Instance* value);
+}

package/include/cluaupp/libs/ezvisual.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+// arxkdev/ezVisualz — EasyVisuals, vendored into CluauppLibs.EzVisualz
+// Effect.new(gui, "Rainbow", speed, size)
+class EzVisualz {
+public:
+	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/include/cluaupp/libs/formatnumber.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+// Blockzez/RobloxFormatNumber — vendored into CluauppLibs.FormatNumber
+// Abbreviate / Comma / Compact are Cluaupp helpers over Simple.FormatCompact.
+class FormatNumberMain {};
+class 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/include/cluaupp/libs/fusion.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+// dphfox/Fusion 0.4 — vendored into CluauppLibs.Fusion
+class FusionScope {};
+class FusionState {};
+class FusionKey {};
+class FusionObserver {};
+class 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/include/cluaupp/libs/iris.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+// SirMallard/Iris — vendored into CluauppLibs.Iris
+class IrisWidget {};
+class 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/include/cluaupp/libs/janitor.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+// howmanysmall/Janitor — vendored into CluauppLibs.Janitor
+class Janitor {
+public:
+	bool CurrentlyCleaning;
+	bool SuppressInstanceReDestroy;
+	bool UnsafeThreadCleanup;
+	Janitor();
+	template <typename T>
+	T Add(T object);
+	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);
+	Janitor* Remove(string index);
+	Janitor* RemoveNoClean(string index);
+	Janitor* RemoveList(string index);
+	template <typename T>
+	T Get(string index);
+	template <typename T>
+	T GetAll();
+	bool Has(string index);
+	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);
+};

package/include/cluaupp/libs/math.hpp

@@ -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/include/cluaupp/libs/module3d.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+// TheNexusAvenger/Module3D — ViewportFrame adorn, vendored into CluauppLibs.Module3D
+class Model3D {
+public:
+	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();
+};
+
+class Module3D {
+public:
+	static Model3D* new_(Instance* model);
+	static Model3D* Attach3D(GuiObject* frame, Instance* model);
+};

package/include/cluaupp/libs/net.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+// Buffer-packed RemoteEvent / RemoteFunction. Names are unique per game.
+class NetEvent {
+public:
+	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)());
+};
+
+class NetFunction {
+public:
+	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/include/cluaupp/libs/promise.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+// evaera/roblox-lua-promise — vendored into CluauppLibs.Promise
+// C++ Then/Catch/Await/Cancel map onto andThen/catch/await/cancel.
+class Promise {
+public:
+	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/include/cluaupp/libs/spring.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+// nightcycle/spring — Fraktality-style damped spring, vendored into CluauppLibs.Spring
+class Spring {
+public:
+	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/include/cluaupp/libs/statemachine.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// Prooheckcp/RobloxStateMachine — vendored into CluauppLibs.StateMachine
+class StateData {};
+
+class StateMachine {
+public:
+	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/include/cluaupp/libs/stickybillboard.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+// Cluaupp StickyBillboard — BillboardGui that stays on an adornee.
+class StickyBillboard {
+public:
+	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/include/cluaupp/libs/topbarplus.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+// 1ForeverHD/TopbarPlus — vendored into CluauppLibs.TopbarPlus (class Icon)
+class IconTheme {};
+
+class Icon {
+public:
+	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/include/cluaupp/libs/twinkle.hpp

@@ -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/include/cluaupp/libs/vfx.hpp

@@ -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/include/cluaupp/libs.hpp

@@ -0,0 +1,25 @@
+#pragma once
+// Cluaupp libraries — C++ IntelliSense. The compiler ignores these headers
+// and emits require(ReplicatedStorage.CluauppLibs.*). Full Luau systems live
+// in runtime/ (vendored from GitHub + Cluaupp originals).
+
+#include <cluaupp/generated/instances.hpp>
+#include <cluaupp/libs/janitor.hpp>
+#include <cluaupp/libs/promise.hpp>
+#include <cluaupp/libs/net.hpp>
+#include <cluaupp/libs/math.hpp>
+#include <cluaupp/libs/formatnumber.hpp>
+#include <cluaupp/libs/module3d.hpp>
+#include <cluaupp/libs/twinkle.hpp>
+#include <cluaupp/libs/dataservice.hpp>
+#include <cluaupp/libs/ezvisual.hpp>
+#include <cluaupp/libs/spring.hpp>
+#include <cluaupp/libs/display.hpp>
+#include <cluaupp/libs/stickybillboard.hpp>
+#include <cluaupp/libs/topbarplus.hpp>
+#include <cluaupp/libs/cmdr.hpp>
+#include <cluaupp/libs/chrono.hpp>
+#include <cluaupp/libs/iris.hpp>
+#include <cluaupp/libs/fusion.hpp>
+#include <cluaupp/libs/statemachine.hpp>
+#include <cluaupp/libs/vfx.hpp>

package/include/cluaupp/roblox.hpp

@@ -0,0 +1,28 @@
+#pragma once
+// Cluaupp — full Roblox API for IntelliSense.
+// Source: official client dump + datatypes from create.roblox.com
+// The compiler ignores #include and emits real Luau (Vector3.new, Instance.new, :GetPlayers, ...).
+
+#include <cluaupp/generated/enums.hpp>
+#include <cluaupp/datatypes.hpp>
+#include <cluaupp/generated/instances.hpp>
+#include <cluaupp/libs.hpp>
+
+template <typename T>
+T* GetService();
+
+template <typename T>
+T* GetService(Instance* game_);
+
+extern DataModel* game;
+extern Workspace* workspace;
+extern LuaSourceContainer* script;
+
+void print(string message);
+void warn(string message);
+void error(string message);
+double tick();
+double time();
+void wait(double seconds = 0);
+void spawn(void (*callback)());
+void delay(double seconds, void (*callback)());