cluaupp 0.1.4 → 0.2.0

package/docs/oop/file-tags.md

@@ -16,34 +16,33 @@ The **filename** decides the Roblox instance. This is the same key idea as roblo
 | `Boot.legacy.server.cpp` | Script | **Legacy** |
 | `Boot.legacy.client.cpp` | LocalScript | Legacy |
 | `Damage.cpp` (no tag) | **ModuleScript** | — |
+| `LeaderstatsServer.h` | **ModuleScript** (types) | — |
+| `LeaderstatsServer.cpp` (sibling of `.h`) | **ModuleScript** (`*Impl`) | — |
 
-## Server is not Legacy
+## One file in, one file out
 
-`.server.cpp` is **not** `init.server.luau`. Rojo maps `*.server.luau` to a Script with RunContext **Legacy**. Cluaupp emits:
+Rojo infers the instance from the filename key: `*.server.luau` is a Script, `*.client.luau` is a LocalScript, untagged `.luau` is a ModuleScript.
 
 ```
-out/server/LeaderstatsServer/
-  init.luau
-  init.meta.json    -- className Script, RunContext Server
+src/server/boot/DataBoot.server.cpp  →  out/server/boot/DataBoot.server.luau
+src/client/boot/DataBoot.client.cpp  →  out/client/boot/DataBoot.client.luau
+src/shared/damage.cpp                →  out/shared/Damage.luau
+src/server/services/leaderstats/LeaderstatsServer.h   →  LeaderstatsServer.luau  (export type)
+src/server/services/leaderstats/LeaderstatsServer.cpp →  LeaderstatsServerImpl.luau
 ```
 
-`.legacy.server.cpp` is the 1:1 dump that *does* become Legacy.
-
-`.client.cpp` stays `init.client.luau` (LocalScript). Do not add `init.meta.json` on the client boot.
+`.legacy.server.cpp` still emits a Legacy Script (`boot.server.luau`). `.client.cpp` stays a LocalScript. Do not invent `init.meta.json` on the default 1:1 path.
 
 ## Where files live
 
 ```
-src/server/.../*.server.cpp   → out/server  (ServerScriptService)
-src/client/.../*.client.cpp   → out/client  (StarterPlayerScripts)
-src/shared/.../*.cpp          → out/shared  (ReplicatedStorage)
+src/server/.../*.server.cpp   → out/server  (ServerScriptService.Cluaupp)
+src/client/.../*.client.cpp   → out/client  (StarterPlayerScripts.Cluaupp)
+src/shared/.../*.cpp          → out/shared  (ReplicatedStorage.Cluaupp)
 ```
 
-Name the **system**, not `init.server.cpp`. `LeaderstatsServer.server.cpp` and `DataBoot.server.cpp` are two services.
-
-## Skip the planner
+Name the **system**, not `init.server.cpp`. `LeaderstatsServer.server.cpp` and `DataBoot.server.cpp` are two files.
 
-- `"architecture": false` in `cluaupp.config.json`, or
-- `.legacy.server.cpp` / `.legacy.client.cpp` per file
+## Opt-in planner
 
-Use legacy only when you want one Luau file with no Main / Controller split.
+`"architecture": true` in `cluaupp.config.json` restores PascalCase service folders (`Main`, Controller, Types). Default is off.

package/docs/oop/index.md

@@ -11,12 +11,12 @@ The **live site** (not just these markdown files) is GitHub Pages:
 - [Guide → OOP](https://kartzrbx.github.io/Cluaupp/guide/oop.html)
 - [Examples](https://kartzrbx.github.io/Cluaupp/guide/examples.html)
 
-Cluaupp does **not** compile custom C++ `class` types yet. “OOP” here is how you **lay out systems** so Studio gets services, modules, and lifecycle — the same idea as roblox-ts filename keys + Flamework `@Service`, without decorators.
+Cluaupp does **not** compile custom C++ `class` types yet. “OOP” here is how you **lay out systems** so Studio gets Script / LocalScript / ModuleScript from the filename tag — the same idea as roblox-ts. Flamework-style Start/Stop folders are opt-in (`"architecture": true`).
 
 | Page | What you learn |
 | --- | --- |
 | [File tags](file-tags.md) | `.server` / `.client` / `.plugin` / `.legacy` / untagged |
-| [Services](services.md) | One `.server.cpp` → Main, Controller, Start / Stop |
+| [Services](services.md) | One `.server.cpp` → one `.server.luau` |
 | [Modules](modules.md) | Untagged files, structs, named functions as methods |
 
 Planner details: [Architecture](../architecture.md). Folder layout: [Organization](../cpp-organization.md). Full services: [Examples](../examples/index.md).

package/docs/oop/modules.md

@@ -25,7 +25,9 @@ int DoubleCoins(int coins) {
 out/shared/util/Coins.luau   -- ModuleScript, exported functions
 ```
 
-Shared **data and constants** belong in headers (`#include "TemplateData.hpp"`) — they are inlined. Untagged `.cpp` is for a ModuleScript other Luau can `require`. Prefer headers for data and tagged `.server.cpp` / `.client.cpp` for behavior.
+Quoted `#include "TemplateData.hpp"` is not inlined when the header has a sibling `.cpp` or is a shared module: `cluaupp build` emits `require(ReplicatedStorage.Cluaupp.constants.TemplateData)` / `require(ServerScriptService.Cluaupp.configurations.PlayerDataVersion)` (Rojo roots from `default.project.json`), never `script.Parent.Parent.shared`.
+
+`.h` / `.hpp` are **type modules**. A service header becomes `export type Name = { init: (self: Name) -> (), … }` and a typed table. The sibling `.cpp` is the construction (`NameImpl.luau`); the header `require`s that impl and binds the functions. Data-only structs still emit a constructor so `TemplateData()` works. Untagged `.cpp` without a header is a ModuleScript other Luau can `require`. Prefer headers for the public type, tagged `.server.cpp` / `.client.cpp` for scripts, and the sibling `.cpp` for method bodies.
 
 ## Structs = data, not classes
 

package/docs/oop/services.md

@@ -5,7 +5,7 @@ sidebar_position: 3
 
 # Services
 
-Write **one tagged file per system**. Cluaupp reads the AST and emits a PascalCase folder: `Main`, managers, controllers, `*Types`.
+Write **one tagged file per system**. Cluaupp emits **one** Luau instance: `LeaderstatsServer.server.luau` from `LeaderstatsServer.server.cpp`. It does not invent Main / Controller / Types unless `"architecture": true`.
 
 ## Example: leaderstats
 
@@ -44,29 +44,22 @@ void init() {
 Typical output:
 
 ```
-out/server/LeaderstatsServer/
-  init.luau              -- Script, RunContext Server
-  init.meta.json
-  Main.luau              -- Start / Stop
-  PlayersManager.luau    -- PlayerAdded + Janitor
-  DataController.luau    -- your WaitFor / GetChangedSignal
-  CacheController.luau   -- if you create IntValue folders
-  LeaderstatsServerTypes.luau
+out/server/services/leaderstats/LeaderstatsServer.server.luau
 ```
 
-Your functions stay in the matching controller. The planner does not drop `SetupPlayerManager` because `init` still calls it.
+Your functions stay in that file. `init()` runs at the end. There is no fake `Main` that only forwards to a Controller.
 
 ## Lifecycle
 
-Generated `Main` exposes `Start` / `Stop`. Managers own a Janitor. `Stop` cleans connections.
+You own `init` and Janitor cleanup in the same file. You do not write `class LeaderstatsServer` — name the **file** `LeaderstatsServer.server.cpp` and keep **functions** as the public API.
 
-You do not write `class LeaderstatsServer` — name the **file** `LeaderstatsServer.server.cpp` and keep **functions** as the public API.
+`"architecture": true` is the old ForeverHD split (`Main.Start` / `Main.Stop`, Managers, Types). Leave it off unless you want that.
 
 ## Boot vs gameplay
 
 Keep DataService `Init` in `DataBoot.server.cpp` / `DataBoot.client.cpp`. Keep leaderstats / combat in their own `.server.cpp`. Services `WaitFor` after boot has run.
 
-## What becomes which role
+## Opt-in roles (`"architecture": true`)
 
 | Your C++ | Generated role |
 | --- | --- |
@@ -78,6 +71,6 @@ Keep DataService `Init` in `DataBoot.server.cpp` / `DataBoot.client.cpp`. Keep l
 | `UserInputService` | `InputController` |
 | wiring | `Main.Start` / `Main.Stop` |
 
-A tiny `print` in `init.client.cpp` stays a single LocalScript. The planner does not invent Managers for hello-world.
+A tiny `print` in `init.client.cpp` stays a single LocalScript.
 
 Copy-paste: [Examples](../examples/index.md).

package/docs/syntax.md

@@ -2,15 +2,16 @@
 
 Cluaupp is not a full C++ compiler. It is a **subset** aimed at Roblox scripts, in the same spirit as roblox-ts (restricted TypeScript → Luau).
 
-Generated Luau follows the current language: [`--!strict`](https://luau.org/getting-started), `local`, `const`, and `const function`. Injected `require` / `GetService` lines are `const`.
+Generated Luau follows the current language: [`local`](https://luau.org/getting-started), `const`, and `const function`. Injected `require` / `GetService` lines are `const`. `--!strict` is emitted only when the file has `#pragma strict` (or `"strict": true` in config).
 
 ## Files
 
 - Extensions: `.cpp`, `.h`, `.hpp` (also `.cc`, `.hh`)
-- Quoted `#include "file.h"` is inlined (C preprocessor)
+- Quoted `#include "file.h"` becomes a Rojo `require` (or is inlined for a header that belongs to the same `.cpp`)
 - `#include <cluaupp/roblox.hpp>` and `<cluaupp/libs/*.hpp>` are IntelliSense only; library headers also inject `require(CluauppLibs.*)`
-- Other `#` lines (`#pragma once`) are ignored
-- Function prototypes (`void foo();`) are skipped; only functions with a body are emitted
+- `#pragma once` is ignored
+- `#pragma strict` / `#pragma nstrict` control `--!strict` for that compilation unit
+- Function prototypes in a `.h` / `.hpp` become `export type` fields (`init: (self: Name) -> ()`). Only `.cpp` files emit function bodies.
 
 ## Functions
 
@@ -199,6 +200,6 @@ Full table and IntelliSense notes: [print and cout](print-cout.md).
 
 ## Not supported yet
 
-Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `std::`, overloading, macros (except skipping `#` lines).
+Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `std::`, overloading, macros (except `#pragma strict` / `#pragma nstrict` / `#pragma once`).
 
 If you need one of those patterns, open an issue with the C++ and the expected Luau.

package/editors/vscode/extension.js

@@ -1,146 +1,97 @@
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const vscode = require("vscode");
-
-function loadEngine(context) {
-	const folders = vscode.workspace.workspaceFolders || [];
-	const workspaceFolder = folders[0] ? folders[0].uri.fsPath : null;
-	const rootFile = path.join(context.extensionPath, "cluaupp.root");
-	const roots = [];
-	if (fs.existsSync(rootFile)) {
-		roots.push(fs.readFileSync(rootFile, "utf8").trim());
-	}
-	if (workspaceFolder) {
-		roots.push(path.join(workspaceFolder, "..", "Cluaupp"));
-		roots.push(path.join(workspaceFolder, "node_modules", "cluaupp"));
-	}
-	roots.push(path.join(context.extensionPath, "..", ".."));
-	for (const root of roots) {
-		const engine = path.join(root, "src", "intellisense.js");
-		if (fs.existsSync(engine)) {
-			return { engine: require(engine), root, workspaceFolder };
-		}
-	}
-	throw new Error("Cluaupp IntelliSense engine not found. Run `cluaupp intellisense` in the game folder.");
-}
-
-function kindOf(kind) {
-	const map = {
-		method: vscode.CompletionItemKind.Method,
-		function: vscode.CompletionItemKind.Function,
-		constructor: vscode.CompletionItemKind.Constructor,
-		property: vscode.CompletionItemKind.Property,
-		variable: vscode.CompletionItemKind.Variable,
-		class: vscode.CompletionItemKind.Class,
-		enum: vscode.CompletionItemKind.Enum,
-		keyword: vscode.CompletionItemKind.Keyword,
-		event: vscode.CompletionItemKind.Event,
-		file: vscode.CompletionItemKind.File,
-	};
-	return map[kind] || vscode.CompletionItemKind.Text;
-}
-
-function activate(context) {
-	let loaded;
-	try {
-		loaded = loadEngine(context);
-	} catch (err) {
-		vscode.window.showWarningMessage(String(err.message || err));
-		return;
-	}
-
-	const selector = { language: "cpp", scheme: "file" };
-	const diagnostics = vscode.languages.createDiagnosticCollection("cluaupp");
-	context.subscriptions.push(diagnostics);
-
-	const optionsFor = (document) => ({
-		projectRoot: loaded.workspaceFolder || path.dirname(document.uri.fsPath),
-		file: document.uri.fsPath,
-		filePath: document.uri.fsPath,
-		includeDirs: [
-			path.dirname(document.uri.fsPath),
-			path.join(loaded.workspaceFolder || "", "src"),
-			path.join(loaded.workspaceFolder || "", "include"),
-		],
-	});
-
-	const refreshDiagnostics = (document) => {
-		if (!document || document.languageId !== "cpp") {
-			return;
-		}
-		const items = loaded.engine.diagnosticsFor(document.getText(), document.uri.fsPath, optionsFor(document));
-		diagnostics.set(
-			document.uri,
-			items.map((item) => {
-				const line = Math.max(0, (item.line || 1) - 1);
-				const col = Math.max(0, (item.col || 1) - 1);
-				const range = new vscode.Range(line, col, line, col + 1);
-				return new vscode.Diagnostic(range, item.message, vscode.DiagnosticSeverity.Error);
-			}),
-		);
-	};
-
-	context.subscriptions.push(
-		vscode.languages.registerCompletionItemProvider(
-			selector,
-			{
-				provideCompletionItems(document, position) {
-					const offset = document.offsetAt(position);
-					const items = loaded.engine.completeAt(document.getText(), offset, optionsFor(document));
-					return items.map((item) => {
-						const completion = new vscode.CompletionItem(item.name, kindOf(item.kind));
-						completion.detail = item.detail || item.type || "";
-						completion.sortText = `${item.kind === "keyword" ? "2" : "0"}_${item.name}`;
-						completion.insertText = item.name;
-						return completion;
-					});
-				},
-			},
-			".",
-			":",
-			">",
-			"<",
-			'"',
-			"/",
-		),
-		vscode.languages.registerHoverProvider(selector, {
-			provideHover(document, position) {
-				const hover = loaded.engine.hoverAt(document.getText(), document.offsetAt(position), optionsFor(document));
-				if (!hover) {
-					return null;
-				}
-				return new vscode.Hover(new vscode.MarkdownString(`**${hover.name}**\n\n\`${hover.detail || hover.type || ""}\``));
-			},
-		}),
-		vscode.languages.registerDefinitionProvider(selector, {
-			provideDefinition(document, position) {
-				const def = loaded.engine.definitionAt(document.getText(), document.offsetAt(position), optionsFor(document));
-				if (!def || !def.file) {
-					return null;
-				}
-				return new vscode.Location(vscode.Uri.file(def.file), new vscode.Position(Math.max(0, (def.line || 1) - 1), 0));
-			},
-		}),
-		vscode.workspace.onDidChangeTextDocument((event) => refreshDiagnostics(event.document)),
-		vscode.workspace.onDidOpenTextDocument(refreshDiagnostics),
-		vscode.commands.registerCommand("cluaupp.restartIntelliSense", () => {
-			try {
-				delete require.cache[require.resolve(path.join(loaded.root, "src", "intellisense.js"))];
-				loaded = loadEngine(context);
-				vscode.window.showInformationMessage("Cluaupp IntelliSense reloaded.");
-			} catch (err) {
-				vscode.window.showErrorMessage(String(err.message || err));
-			}
-		}),
-	);
-
-	for (const document of vscode.workspace.textDocuments) {
-		refreshDiagnostics(document);
-	}
-}
-
-function deactivate() {}
-
-module.exports = { activate, deactivate };
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const vscode = require("vscode");
+
+function loadEngine(context) {
+	const folders = vscode.workspace.workspaceFolders || [];
+	const workspaceFolder = folders[0] ? folders[0].uri.fsPath : null;
+	const rootFile = path.join(context.extensionPath, "cluaupp.root");
+	const roots = [];
+	if (fs.existsSync(rootFile)) {
+		roots.push(fs.readFileSync(rootFile, "utf8").trim());
+	}
+	if (workspaceFolder) {
+		roots.push(path.join(workspaceFolder, "..", "Cluaupp"));
+		roots.push(path.join(workspaceFolder, "node_modules", "cluaupp"));
+	}
+	roots.push(path.join(context.extensionPath, "..", ".."));
+	for (const root of roots) {
+		const candidates = [
+			path.join(root, "generated", "intellisense.js"),
+			path.join(root, "src", "intellisense.js"),
+		];
+		for (const engine of candidates) {
+			if (fs.existsSync(engine)) {
+				return { engine: require(engine), root, workspaceFolder, enginePath: engine };
+			}
+		}
+	}
+	throw new Error("Cluaupp diagnostics engine not found. Run `cluaupp intellisense` in the game folder.");
+}
+
+function activate(context) {
+	let loaded;
+	try {
+		loaded = loadEngine(context);
+	} catch (err) {
+		vscode.window.showWarningMessage(String(err.message || err));
+		return;
+	}
+
+	const diagnostics = vscode.languages.createDiagnosticCollection("cluaupp");
+	context.subscriptions.push(diagnostics);
+
+	const optionsFor = (document) => ({
+		projectRoot: loaded.workspaceFolder || path.dirname(document.uri.fsPath),
+		file: document.uri.fsPath,
+		filePath: document.uri.fsPath,
+		includeDirs: [
+			path.dirname(document.uri.fsPath),
+			path.join(loaded.workspaceFolder || "", "src"),
+			path.join(loaded.workspaceFolder || "", "include"),
+		],
+	});
+
+	const refreshDiagnostics = (document) => {
+		if (!document || document.languageId !== "cpp") {
+			return;
+		}
+		if (typeof loaded.engine.diagnosticsFor !== "function") {
+			return;
+		}
+		const items = loaded.engine.diagnosticsFor(document.getText(), document.uri.fsPath, optionsFor(document));
+		diagnostics.set(
+			document.uri,
+			items.map((item) => {
+				const line = Math.max(0, (item.line || 1) - 1);
+				const col = Math.max(0, (item.col || 1) - 1);
+				const range = new vscode.Range(line, col, line, col + 1);
+				return new vscode.Diagnostic(range, item.message, vscode.DiagnosticSeverity.Error);
+			}),
+		);
+	};
+
+	context.subscriptions.push(
+		vscode.workspace.onDidChangeTextDocument((event) => refreshDiagnostics(event.document)),
+		vscode.workspace.onDidOpenTextDocument(refreshDiagnostics),
+		vscode.commands.registerCommand("cluaupp.restartIntelliSense", () => {
+			try {
+				delete require.cache[require.resolve(loaded.enginePath)];
+				loaded = loadEngine(context);
+				vscode.window.showInformationMessage("Cluaupp diagnostics reloaded. C++ completion is clangd.");
+			} catch (err) {
+				vscode.window.showErrorMessage(String(err.message || err));
+			}
+		}),
+	);
+
+	for (const document of vscode.workspace.textDocuments) {
+		refreshDiagnostics(document);
+	}
+}
+
+function deactivate() {}
+
+module.exports = { activate, deactivate };

package/editors/vscode/package.json

@@ -1,14 +1,14 @@
 {
-	"name": "cluaupp-intellisense",
-	"displayName": "Cluaupp IntelliSense",
-	"description": "Completions, hover, and go-to-definition for Cluaupp C++ (Roblox APIs, DataService paths, project structs).",
-	"version": "0.1.4",
+	"name": "cluaupp-diagnostics",
+	"displayName": "Cluaupp",
+	"description": "Cluaupp subset parse errors. C++ completion, hover, and go-to-definition come from clangd + include/cluaupp/roblox.hpp.",
+	"version": "0.2.0",
 	"publisher": "kartzdev",
 	"engines": {
 		"vscode": "^1.74.0"
 	},
 	"categories": [
-		"Programming Languages"
+		"Linters"
 	],
 	"activationEvents": [
 		"onLanguage:cpp"
@@ -18,7 +18,7 @@
 		"commands": [
 			{
 				"command": "cluaupp.restartIntelliSense",
-				"title": "Cluaupp: Restart IntelliSense"
+				"title": "Cluaupp: Reload subset diagnostics"
 			}
 		]
 	}

package/examples/README.md

@@ -0,0 +1,18 @@
+# Sample game
+
+This is the C++ a Cluaupp game looks like — **not** the compiler.
+
+| Folder | Rojo | Tag |
+| --- | --- | --- |
+| `src/server/*.server.cpp` | Script | server |
+| `src/client/*.client.cpp` | LocalScript | client |
+| `src/shared/*` | ModuleScript | none |
+
+`src/` of **this repo** is the TypeScript CLI ([roblox-ts](https://github.com/roblox-ts/roblox-ts) does the same). The sample scripts live here so they never mix with `understand.ts`.
+
+```bash
+cd examples/game
+npx cluaupp build .
+```
+
+`cluaupp init` copies `templates/game` (the slim scaffold). This folder adds combat / HUD so `SystemUnderstander` has real tokens to score.

package/examples/game/.clangd

@@ -0,0 +1,25 @@
+CompileFlags:
+  CompilationDatabase: .
+  Add:
+    - -xc++
+    - -std=c++20
+    - -ferror-limit=0
+    - -Iinclude
+    - -Isrc
+    - -I../../include
+
+Diagnostics:
+  Suppress: '*'
+
+---
+If:
+  PathMatch: .*\.(cpp|cc|cxx|c|h|hpp|hh)$
+CompileFlags:
+  Add:
+    - -xc++
+
+---
+If:
+  PathMatch: (out|libs)/.*
+Index:
+  Background: Skip

package/examples/game/.vscode/c_cpp_properties.json

@@ -0,0 +1,27 @@
+{
+	"configurations": [
+		{
+			"name": "Cluaupp",
+			"compilerPath": "clang++",
+			"cStandard": "c17",
+			"cppStandard": "c++20",
+			"intelliSenseMode": "windows-clang-x64",
+			"includePath": [
+				"${workspaceFolder}/include",
+				"${workspaceFolder}/src"
+			],
+			"forcedInclude": [
+				"${workspaceFolder}/include/cluaupp/roblox.hpp"
+			],
+			"compileCommands": "${workspaceFolder}/compile_commands.json",
+			"browse": {
+				"path": [
+					"${workspaceFolder}/include",
+					"${workspaceFolder}/src"
+				],
+				"limitSymbolsToIncludedHeaders": true
+			}
+		}
+	],
+	"version": 4
+}

package/examples/game/.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+	"recommendations": [
+		"llvm-vs-code-extensions.vscode-clangd"
+	]
+}

package/examples/game/.vscode/settings.json

@@ -0,0 +1,27 @@
+{
+	"C_Cpp.intelliSenseEngine": "Disabled",
+	"C_Cpp.default.cppStandard": "c++20",
+	"C_Cpp.default.cStandard": "c17",
+	"C_Cpp.default.compilerPath": "clang++",
+	"C_Cpp.default.intelliSenseMode": "windows-clang-x64",
+	"C_Cpp.default.includePath": [
+		"${workspaceFolder}/include",
+		"${workspaceFolder}/src"
+	],
+	"clangd.enable": true,
+	"clangd.arguments": [
+		"--compile-commands-dir=${workspaceFolder}",
+		"--header-insertion=never",
+		"--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe"
+	],
+	"files.associations": {
+		"*.hpp": "cpp",
+		"*.h": "cpp",
+		"*.server.cpp": "cpp",
+		"*.client.cpp": "cpp",
+		"*.plugin.cpp": "cpp",
+		"*.legacy.cpp": "cpp",
+		"*.legacy.server.cpp": "cpp",
+		"*.legacy.client.cpp": "cpp"
+	}
+}

package/examples/game/cluaupp.config.json

@@ -0,0 +1,6 @@
+{
+	"rootDir": "src",
+	"outDir": "out",
+	"strict": false,
+	"architecture": false
+}

package/examples/game/compile_flags.txt

@@ -0,0 +1,6 @@
+-xc++
+-std=c++20
+-ferror-limit=0
+-Iinclude
+-Isrc
+-I../../include

package/examples/game/default.project.json

@@ -0,0 +1,39 @@
+{
+	"name": "cluaupp-game",
+	"tree": {
+		"$className": "DataModel",
+		"ServerScriptService": {
+			"$className": "ServerScriptService",
+			"Cluaupp": {
+				"$path": "out/server"
+			}
+		},
+		"ReplicatedStorage": {
+			"$className": "ReplicatedStorage",
+			"Cluaupp": {
+				"$path": "out/shared"
+			},
+			"CluauppLibs": {
+				"$path": "libs"
+			},
+			"Packages": {
+				"$path": "Packages"
+			}
+		},
+		"StarterPlayer": {
+			"$className": "StarterPlayer",
+			"StarterPlayerScripts": {
+				"$className": "StarterPlayerScripts",
+				"Cluaupp": {
+					"$path": "out/client"
+				}
+			}
+		},
+		"HttpService": {
+			"$className": "HttpService",
+			"$properties": {
+				"HttpEnabled": true
+			}
+		}
+	}
+}

package/examples/game/package.json

@@ -0,0 +1,9 @@
+{
+	"name": "cluaupp-game",
+	"private": true,
+	"scripts": {
+		"build": "cluaupp build",
+		"watch": "cluaupp watch",
+		"dev": "cluaupp watch"
+	}
+}

package/examples/game/rokit.toml

@@ -0,0 +1,5 @@
+# This file lists tools managed by Rokit, a toolchain manager for Roblox projects.
+# https://github.com/rojo-rbx/rokit
+
+[tools]
+rojo = "rojo-rbx/rojo@7.7.0"

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

@@ -0,0 +1,12 @@
+#pragma strict
+#include <cluaupp/roblox.hpp>
+
+void init() {
+	auto* playerGui = GetService<Players>()->LocalPlayer->FindFirstChild("PlayerGui");
+	auto* screen = new ScreenGui();
+	screen->Name = "Hud";
+	auto* coins = new TextLabel();
+	coins->Name = "Coins";
+	coins->Parent = screen;
+	print("hud ready");
+}

package/{src → examples/game/src}/client/init.client.cpp

@@ -1,3 +1,4 @@
+#pragma strict
 #include <cluaupp/roblox.hpp>
 
 void init() {