cluaupp 0.2.3 → 1.3.0

package/examples/game/libs/TopbarPlus/init.luau

@@ -0,0 +1,8 @@
+--!strict
+-- Cluaupp TopbarPlus — typed border. Public value is Icon.
+
+local Impl = require(script._impl)
+
+export type Icon = Impl.Icon
+
+return Impl

package/examples/game/libs/Twinkle/init.luau

@@ -0,0 +1,157 @@
+--!strict
+--[=[
+	@class Twinkle
+	UI motion without TweenService boilerplate: fade, slide, zoom, bounce, button styles.
+	Inspired by [Twinkle](https://devforum.roblox.com/t/twinkle-free-powerful-ui-animator-module/4512304).
+]=]
+local TweenService = game:GetService("TweenService")
+
+export type HoverType = "Lift" | "Bounce" | "Grow"
+export type PressType = "Shrink" | "Punch"
+export type TweenProps = {
+	BackgroundTransparency: number?,
+	TextTransparency: number?,
+	Position: UDim2?,
+	Size: UDim2?,
+}
+
+local Twinkle = {}
+
+local function tween(inst: Instance, info: TweenInfo, props: TweenProps): Tween
+	local t = TweenService:Create(inst, info, props)
+	t:Play()
+	return t
+end
+
+local function infoOf(speed: number?, style: Enum.EasingStyle?, dir: Enum.EasingDirection?): TweenInfo
+	return TweenInfo.new(speed or 0.25, style or Enum.EasingStyle.Quad, dir or Enum.EasingDirection.Out)
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param show boolean
+	@param speed number?
+]=]
+function Twinkle.Fade(element: GuiObject, show: boolean, speed: number?)
+	element.Visible = true
+	tween(element, infoOf(speed), { BackgroundTransparency = if show then 0 else 1 })
+	if element:IsA("TextLabel") or element:IsA("TextButton") or element:IsA("TextBox") then
+		tween(element, infoOf(speed), { TextTransparency = if show then 0 else 1 })
+	end
+	if not show then
+		task.delay(speed or 0.25, function()
+			element.Visible = false
+		end)
+	end
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param show boolean
+	@param speed number?
+]=]
+function Twinkle.FrameSlide(element: GuiObject, show: boolean, speed: number?)
+	local original = element.Position
+	if show then
+		element.Visible = true
+		element.Position = original + UDim2.fromOffset(0, 24)
+		tween(element, infoOf(speed), { Position = original, BackgroundTransparency = 0 })
+	else
+		tween(element, infoOf(speed), { Position = original + UDim2.fromOffset(0, 24), BackgroundTransparency = 1 })
+		task.delay(speed or 0.25, function()
+			element.Visible = false
+			element.Position = original
+		end)
+	end
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param show boolean
+	@param speed number?
+]=]
+function Twinkle.FrameZoom(element: GuiObject, show: boolean, speed: number?)
+	local original = element.Size
+	if show then
+		element.Visible = true
+		element.Size = UDim2.new(original.X.Scale * 0.9, original.X.Offset, original.Y.Scale * 0.9, original.Y.Offset)
+		tween(element, infoOf(speed, Enum.EasingStyle.Back), { Size = original })
+	else
+		tween(element, infoOf(speed), {
+			Size = UDim2.new(original.X.Scale * 0.9, original.X.Offset, original.Y.Scale * 0.9, original.Y.Offset),
+		})
+		task.delay(speed or 0.25, function()
+			element.Visible = false
+			element.Size = original
+		end)
+	end
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param speed number?
+	@param bouncePercent number?
+]=]
+function Twinkle.FrameBounce(element: GuiObject, speed: number?, bouncePercent: number?)
+	local original = element.Size
+	local percent = bouncePercent or 0.08
+	local bigger = UDim2.new(
+		original.X.Scale * (1 + percent),
+		original.X.Offset,
+		original.Y.Scale * (1 + percent),
+		original.Y.Offset
+	)
+	local t = tween(element, infoOf(speed or 0.12, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), { Size = bigger })
+	t.Completed:Connect(function()
+		tween(element, infoOf(speed or 0.12, Enum.EasingStyle.Quad, Enum.EasingDirection.In), { Size = original })
+	end)
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param hoverType string? -- Lift | Bounce | Grow
+	@param pressType string? -- Shrink | Punch
+	@param scalePercent number?
+]=]
+function Twinkle.SetButtonStyle(element: GuiObject, hoverType: HoverType?, pressType: PressType?, scalePercent: number?)
+	local original = element.Size
+	local originalPos = element.Position
+	local percent = scalePercent or 0.06
+	if element:IsA("GuiButton") then
+		element.MouseEnter:Connect(function()
+			if hoverType == "Lift" then
+				tween(element, infoOf(0.12), { Position = originalPos + UDim2.fromOffset(0, -4) })
+			else
+				Twinkle.FrameBounce(element, 0.1, percent)
+			end
+		end)
+		element.MouseLeave:Connect(function()
+			tween(element, infoOf(0.12), { Position = originalPos, Size = original })
+		end)
+		element.MouseButton1Down:Connect(function()
+			if pressType == "Punch" then
+				Twinkle.FrameBounce(element, 0.08, percent * 1.4)
+			else
+				local smaller = UDim2.new(
+					original.X.Scale * (1 - percent),
+					original.X.Offset,
+					original.Y.Scale * (1 - percent),
+					original.Y.Offset
+				)
+				tween(element, infoOf(0.08), { Size = smaller })
+			end
+		end)
+		element.MouseButton1Up:Connect(function()
+			tween(element, infoOf(0.1), { Size = original })
+		end)
+	end
+end
+
+export type Twinkle = typeof(Twinkle)
+
+return Twinkle

package/examples/game/libs/VfxUtil/init.luau

@@ -0,0 +1,164 @@
+--!strict
+--[=[
+	@class VfxUtil
+	Emit, play, stop, scale, and clone visual-effect templates (ParticleEmitter,
+	Beam, Trail, Sound, Animation). There was no public GitHub for
+	lucaschaibub/vfx-util; this is the full Cluaupp system.
+
+	```lua
+	VfxUtil.Emit(attachment, 12)
+	local clone = VfxUtil.CloneOnto(template, character.HumanoidRootPart)
+	VfxUtil.Play(clone)
+	task.delay(2, function()
+		VfxUtil.DestroyAfter(clone, 0.4)
+	end)
+	```
+]=]
+local Debris = game:GetService("Debris")
+
+local VfxUtil = {}
+
+export type EffectInstance = ParticleEmitter | Beam | Trail | Sound | Fire | Smoke | Sparkles
+
+local function isEffect(inst: Instance): boolean
+	return inst:IsA("ParticleEmitter")
+		or inst:IsA("Beam")
+		or inst:IsA("Trail")
+		or inst:IsA("Sound")
+		or inst:IsA("Fire")
+		or inst:IsA("Smoke")
+		or inst:IsA("Sparkles")
+end
+
+local function collect(root: Instance): { Instance }
+	local found = {}
+	if isEffect(root) then
+		table.insert(found, root)
+	end
+	for _, child in root:GetDescendants() do
+		if isEffect(child) then
+			table.insert(found, child)
+		end
+	end
+	return found
+end
+
+--[=[
+	@within VfxUtil
+	@param root Instance -- Attachment, Part, or a folder of emitters
+	@param count number? -- particles to emit; default 8
+]=]
+function VfxUtil.Emit(root: Instance, count: number?)
+	local amount = count or 8
+	for _, inst in collect(root) do
+		if inst:IsA("ParticleEmitter") then
+			inst:Emit(amount)
+		elseif inst:IsA("Sound") then
+			inst:Play()
+		elseif inst:IsA("Beam") or inst:IsA("Trail") then
+			inst.Enabled = true
+		elseif inst:IsA("Fire") or inst:IsA("Smoke") or inst:IsA("Sparkles") then
+			inst.Enabled = true
+		end
+	end
+end
+
+--[=[
+	@within VfxUtil
+	Enables looping emitters / beams / trails and plays sounds.
+]=]
+function VfxUtil.Play(root: Instance)
+	for _, inst in collect(root) do
+		if inst:IsA("ParticleEmitter") or inst:IsA("Beam") or inst:IsA("Trail") then
+			inst.Enabled = true
+		elseif inst:IsA("Sound") then
+			inst:Play()
+		elseif inst:IsA("Fire") or inst:IsA("Smoke") or inst:IsA("Sparkles") then
+			inst.Enabled = true
+		end
+	end
+end
+
+--[=[
+	@within VfxUtil
+]=]
+function VfxUtil.Stop(root: Instance)
+	for _, inst in collect(root) do
+		if inst:IsA("ParticleEmitter") or inst:IsA("Beam") or inst:IsA("Trail") then
+			inst.Enabled = false
+		elseif inst:IsA("Sound") then
+			inst:Stop()
+		elseif inst:IsA("Fire") or inst:IsA("Smoke") or inst:IsA("Sparkles") then
+			inst.Enabled = false
+		end
+	end
+end
+
+--[=[
+	@within VfxUtil
+	@param template Instance
+	@param parent Instance
+	@return Instance
+	Clones a VFX template onto `parent` (Attachment / BasePart / Model).
+]=]
+function VfxUtil.CloneOnto(template: Instance, parent: Instance): Instance
+	local clone = template:Clone()
+	if clone:IsA("Attachment") and parent:IsA("BasePart") then
+		clone.Parent = parent
+	elseif clone:IsA("BasePart") and parent:IsA("Model") then
+		clone.Parent = parent
+	else
+		clone.Parent = parent
+	end
+	return clone
+end
+
+--[=[
+	@within VfxUtil
+	Scales NumberSequence / NumberRange particle sizes by `factor`.
+]=]
+function VfxUtil.Scale(root: Instance, factor: number)
+	for _, inst in collect(root) do
+		if inst:IsA("ParticleEmitter") then
+			local size = inst.Size
+			local keys = {}
+			for index, keypoint in size.Keypoints do
+				keys[index] = NumberSequenceKeypoint.new(keypoint.Time, keypoint.Value * factor, keypoint.Envelope * factor)
+			end
+			inst.Size = NumberSequence.new(keys)
+			local spread = inst.SpreadAngle
+			inst.SpreadAngle = Vector2.new(spread.X * factor, spread.Y * factor)
+		elseif inst:IsA("Sound") then
+			inst.PlaybackSpeed = math.clamp(inst.PlaybackSpeed * factor, 0.1, 4)
+		end
+	end
+end
+
+--[=[
+	@within VfxUtil
+	Stops effects then destroys the instance after `lifetime` seconds.
+]=]
+function VfxUtil.DestroyAfter(root: Instance, lifetime: number?)
+	local delayTime = lifetime or 1
+	task.delay(delayTime * 0.6, function()
+		if root.Parent then
+			VfxUtil.Stop(root)
+		end
+	end)
+	Debris:AddItem(root, delayTime)
+end
+
+--[=[
+	@within VfxUtil
+	One-shot: clone, emit, destroy.
+]=]
+function VfxUtil.Burst(template: Instance, parent: Instance, count: number?, lifetime: number?): Instance
+	local clone = VfxUtil.CloneOnto(template, parent)
+	VfxUtil.Emit(clone, count)
+	VfxUtil.DestroyAfter(clone, lifetime or 2)
+	return clone
+end
+
+export type VfxUtil = typeof(VfxUtil)
+
+return VfxUtil

package/examples/game/src/client/hud.client.clpp

@@ -0,0 +1,54 @@
+#pragma strict
+#include <clpp/roblox.clh>
+#include <clpp/libs/fusion.clh>
+
+[[client]]
+void init() {
+	Players players = GetService<Players>();
+	Player localPlayer = players.LocalPlayer;
+	guard (localPlayer != null) else {
+		report("LocalPlayer missing");
+		return;
+	}
+
+	Instance playerGui = localPlayer.WaitForChild("PlayerGui");
+	auto scope = Fusion.scoped();
+	auto Children = Fusion.Children;
+
+	auto coins = Fusion.Value(scope, 0);
+	auto title = Fusion.Computed(scope, func () {
+		return "Coins: " .: coins();
+	});
+
+	auto newScreenGui = Fusion.New(scope, "ScreenGui");
+	auto newFrame = Fusion.New(scope, "Frame");
+	auto newLabel = Fusion.New(scope, "TextLabel");
+
+	auto label = newLabel({
+		{"Name", "Amount"},
+		{"BackgroundTransparency", 1},
+		{"Size", UDim2::fromScale(1, 1)},
+		{"Text", title},
+		{"TextColor3", Color3::fromRGB(255, 255, 255)},
+		{"TextScaled", true}
+	});
+
+	auto frame = newFrame({
+		{"Name", "Hud"},
+		{"AnchorPoint", Vector2(0, 1)},
+		{"Position", UDim2::fromScale(0, 1)},
+		{"Size", UDim2::fromOffset(220, 64)},
+		{"BackgroundColor3", Color3::fromRGB(28, 18, 48)},
+		{Children, label}
+	});
+
+	newScreenGui({
+		{"Name", "CoinsHud"},
+		{"ResetOnSpawn", false},
+		{"Parent", playerGui},
+		{Children, frame}
+	});
+
+	coins(100);
+	post("hud ready");
+}

package/examples/game/src/client/init.client.clpp

@@ -0,0 +1,6 @@
+#pragma strict
+#include <clpp/roblox.clh>
+
+void init() {
+	post("Cluaupp client ok");
+}

package/examples/game/src/server/combat.server.clpp

@@ -0,0 +1,85 @@
+#pragma strict
+#include <clpp/roblox.clh>
+#include <clpp/libs/janitor.clh>
+
+struct CombatServer {
+	Janitor janitor;
+	signal<Player, int> OnHit;
+	void PlayerEntered(Player player);
+	void BindPart(BasePart part);
+	void WatchWorkspace();
+};
+
+void CombatServer::BindPart(BasePart part) {
+	guard (part != null) else {
+		return;
+	}
+
+	part.Touched~>Once(func (BasePart other) {
+		Instance character = other.Parent;
+		guard (character != null) else {
+			return;
+		}
+
+		match (character.FindFirstChild("Humanoid")) {
+			Humanoid humanoid => {
+				guard (humanoid.Health > 0) else {
+					return;
+				}
+				Players players = GetService<Players>();
+				Player player = players.GetPlayerFromCharacter(character);
+				guard (player != null) else {
+					return;
+				}
+				OnHit.Fire(player, 10);
+				part.Destroy();
+			},
+			_ => warn("touch without humanoid")
+		};
+	});
+}
+
+void CombatServer::PlayerEntered(Player player) {
+	guard (player != null) else {
+		return;
+	}
+
+	observable int combo = 0;
+	OnHit~>Connect(func (Player victim, int amount) {
+		guard (victim == player) else {
+			return;
+		}
+		combo = combo + 1;
+		post(player.Name .: " combo " .: combo .: " dmg " .: amount);
+	});
+}
+
+[[server]]
+void CombatServer::WatchWorkspace() {
+	workspace.ChildAdded~>Connect(func (Instance child) {
+		match (child) {
+			BasePart p => BindPart(p),
+			Model m => post("model spawned " .: m.Name),
+			_ => warn("ignored instance")
+		};
+	});
+}
+
+void init() {
+	CombatServer combat;
+	combat.janitor = new Janitor();
+
+	spawn {
+		task::wait(1);
+		post("combat ready");
+	};
+
+	Players players = GetService<Players>();
+	for (Player player in players.GetPlayers()) {
+		combat.PlayerEntered(player);
+	}
+	players.PlayerAdded~>Connect(func (Player p) {
+		combat.PlayerEntered(p);
+	});
+	combat.WatchWorkspace();
+}

package/examples/game/src/server/leaderstats.server.clpp

@@ -0,0 +1,28 @@
+#pragma strict
+#include <clpp/roblox.clh>
+
+void CreateLeaderstats(Player player) {
+	if (player.FindFirstChild("leaderstats") != null) {
+		return;
+	}
+
+	Folder leaderstats = new Folder(player);
+	leaderstats.Name = "leaderstats";
+
+	IntValue coins = new IntValue(leaderstats);
+	coins.Name = "Coins";
+	coins.Value = 0;
+
+	IntValue level = new IntValue(leaderstats);
+	level.Name = "Level";
+	level.Value = 0;
+}
+
+void init() {
+	Players players = GetService<Players>();
+	for (Player player in players.GetPlayers()) {
+		CreateLeaderstats(player);
+	}
+
+	players.PlayerAdded~>Connect(CreateLeaderstats);
+}

package/examples/game/src/shared/PlayerData.clh

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <clpp/datatypes.clh>
+
+struct PlayerDataCurrencies {
+	int Coins = 0;
+	int Rebirths = 0;
+};
+
+struct PlayerDataInventory {
+	array<int> HotBar;
+	array<int> Storage;
+
+	int MaxStorage = 90;
+};
+
+struct PlayerData {
+	PlayerDataCurrencies Currencies;
+	PlayerDataInventory Inventory;
+};

package/examples/game/src/shared/config.clp

@@ -0,0 +1,6 @@
+#pragma once
+#include <clpp/roblox.clh>
+
+const int STARTING_COINS = 0;
+const string REMOTE_COINS = "Coins";
+const string LEADERSTATS_FOLDER = "leaderstats";

package/examples/game/src/shared/features.clp

@@ -0,0 +1,100 @@
+#pragma once
+#include <clpp/roblox.clh>
+
+struct Wallet {
+	int coins;
+	void Add(int n);
+};
+
+void Wallet::Add(int n) {
+	@coins = coins + n;
+	post("wallet " .: @coins);
+}
+
+void ShowcaseFeatures(int coins, Player playerRef) {
+	int n = 100;
+	float speed = 16.5;
+	string name = "Kartz";
+	bool isActive = true;
+	func callback = func () {};
+	post(speed);
+	post(isActive);
+	callback();
+
+	Wallet pocket;
+	pocket.Add(10);
+
+	array<string> names = {"Kartz", "Player1"};
+	dictionary<string, int> stats = {
+		{"Coins", 100},
+		{"Gems", 50}
+	};
+	post(names);
+	post(stats);
+
+	if (coins > 50) {
+		post("Enough balance!");
+	} else if (coins == 0) {
+		warn("No coins!");
+	} else {
+		report("Balance sync error.");
+	}
+
+	for (int i = 0; i < 10; i++) {
+		post("Count: " .: i);
+	}
+
+	n += 1;
+
+	observable int wallet = 100;
+	wallet.OnChange(func (int newValue) {
+		post("Coins changed to: " .: newValue);
+	});
+
+	signal<Player, int> OnCoinsUpdated;
+	OnCoinsUpdated~>Connect(func (Player player, int newAmount) {
+		post("New coins for " .: player.Name .: ": " .: newAmount);
+	});
+	OnCoinsUpdated~>Once(func (Player player, int newAmount) {
+		post("First coins for " .: player.Name .: " " .: newAmount);
+	});
+	OnCoinsUpdated.Fire(playerRef, wallet);
+
+	guard (playerRef != null) else {
+		warn("Invalid player");
+		return;
+	}
+
+	playerRef.GetPropertyChangedSignal("Name")~>Connect(func () {
+		post("Name changed");
+	});
+
+	auto [success, result] = pcall(func () {
+		return 1;
+	});
+	post(result);
+
+	const int moeda = 4;
+	match (moeda) {
+		int a => post(a),
+		_ => post("Not found")
+	};
+
+	if (success) {
+		post("Data loaded successfully!");
+	}
+
+	spawn {
+		task::wait(2);
+		post("Delay finished!");
+	};
+
+	parallel {
+		post("desync");
+	};
+
+	match (name) {
+		string s => post(s),
+		_ => warn("Instance not supported")
+	};
+}