el4cteo/roblox-skills

roblox-architecture

Roblox project structure and client/server model - replication, where code and assets belong (ServerScriptService, ReplicatedStorage, StarterPlayer), RunContext, service/controller bootstrapping, player/character lifecycle, CollectionService components, att…

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/el4cteo/roblox-skills --skill roblox-architecture

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

Roblox game architecture

The model in one paragraph

Every Roblox game is a server (authoritative, runs Scripts, sees everything, owns DataStores) plus one client per player (runs LocalScripts / client Scripts, renders, reads input). The server's DataModel replicates to clients automatically. Client changes do not replicate back, except: physics of parts the client has network ownership of (its character by default), its own Humanoid state/animations, and remote calls. Assume every client is compromised (see roblox-security). Design every feature as: client requests → server validates and decides → state replicates → clients render.

Where things go

ContainerRuns/visible onPut here
ServerScriptServiceServer onlyServer Scripts and server-only ModuleScripts (game logic, data, anti-cheat).
ServerStorageServer onlyServer-only assets: maps, NPC templates, tools to clone, secrets-adjacent config.
ReplicatedStorageBothShared modules (types, config, pure utils), RemoteEvents, assets clients clone.
ReplicatedFirstClient, firstLoading screen only. Replicates before everything else.
StarterPlayer.StarterPlayerScriptsClient (copied once to PlayerScripts)Client entry point and controllers.
StarterPlayer.StarterCharacterScriptsClient (copied per spawn into character)Per-character client scripts (rarely needed).
StarterGuiClient (copied to PlayerGui)ScreenGuis. Set ResetOnSpawn = false unless you want reset on death.
WorkspaceBoth (streamed to clients)The 3D world only. Not a place for code or templates.
Lighting, SoundService, Teams, TextChatServiceBothTheir respective config objects.

Rules:

  • Code in ReplicatedStorage is downloadable by exploiters. Never put server logic, secrets,

admin lists, or anti-cheat thresholds there.

  • Script.RunContext: Legacy (default: behavior depends on the container), Server, Client, or

Plugin. A non-Legacy RunContext makes a Script run regardless of container (e.g. a Client Script in ReplicatedStorage runs on every client) — so templates you clone must not contain such scripts unintentionally. Legacy Scripts don't run in ReplicatedStorage/ServerStorage.

Project layout (Rojo-style, recommended)

text
src/
  server/            -> ServerScriptService.Server   (init.server.luau = entry point)
    Services/        -> one ModuleScript per system (DataService, CombatService, ...)
  client/            -> StarterPlayer.StarterPlayerScripts.Client (init.client.luau)
    Controllers/     -> one ModuleScript per client system (InputController, UIController, ...)
  shared/            -> ReplicatedStorage.Shared (types, config, pure logic, network definitions)
Packages/            -> ReplicatedStorage.Packages (Wally/pesde dependencies)
ServerPackages/      -> ServerScriptService.ServerPackages

One entry script per side, everything else is a ModuleScript. This gives deterministic load order, testable modules, and a single place to wire dependencies. Roblox's own recommendation is equivalent: one Script (RunContext = Server) in ServerScriptService and one Script (RunContext = Client) in ReplicatedStorage, each requiring modules and calling their start(). Tooling setup: roblox-tooling.

Bootstrapping services (no framework needed)

luau
--!strict
-- ServerScriptService/Server/init.server.luau
type Service = {
	init: ((self: Service) -> ())?, -- sync setup; may reference other services; must not yield
	start: ((self: Service) -> ())?, -- runs after every init; may yield / connect events
}

local servicesFolder = script:WaitForChild("Services")
local services: { [string]: Service } = {}

for _, module in servicesFolder:GetChildren() do
	if module:IsA("ModuleScript") then
		services[module.Name] = (require :: any)(module)
	end
end

for name, service in services do
	if service.init then
		debug.setmemorycategory(name)
		service:init()
		debug.resetmemorycategory()
	end
end

for name, service in services do
	if service.start then
		task.spawn(function()
			debug.setmemorycategory(name)
			service:start()
		end)
	end
end
  • Services reference each other with plain require (no cycles) or receive dependencies in init.
  • The client mirrors this with Controllers. Keep names symmetrical (ShopService / ShopController).
  • Frameworks like Knit are unnecessary for this; if a project already uses one, follow its conventions.

Player and character lifecycle

luau
--!strict
local Players = game:GetService("Players")

local function onCharacterAdded(player: Player, character: Model)
	local humanoid = character:WaitForChild("Humanoid") :: Humanoid
	humanoid.Died:Once(function()
		print(`{player.Name} died`)
	end)
end

local function onPlayerAdded(player: Player)
	-- Load data first (see roblox-data-stores), then set up character handling.
	if player.Character then
		task.spawn(onCharacterAdded, player, player.Character)
	end
	player.CharacterAdded:Connect(function(character)
		onCharacterAdded(player, character)
	end)
end

local function onPlayerRemoving(player: Player)
	-- Save data, release session locks, clear every table keyed by this player.
	print(`{player.Name} left`)
end

Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)
for _, player in Players:GetPlayers() do -- players who joined before this script connected
	task.spawn(onPlayerAdded, player)
end

game:BindToClose(function()
	-- Server shutdown: flush saves for remaining players (max ~30 s total).
end)
  • Always handle players/characters that already exist when your code starts.
  • Characters respawn: anything bound to a character must be re-created on CharacterAdded.
  • On the client, character descendants may not exist yet (streaming): WaitForChild them.

Components with CollectionService tags

Tag instances (Studio Tags section or CollectionService:AddTag) and attach behavior in code. This scales better than copying scripts into every model and works with streaming because the added/removed signals fire as instances stream in and out.

luau
--!strict
local CollectionService = game:GetService("CollectionService")

local TAG = "KillBrick"
local cleanups: { [Instance]: () -> () } = {}

local function onAdded(instance: Instance)
	if not instance:IsA("BasePart") then
		return
	end
	local connection = instance.Touched:Connect(function(hit)
		local humanoid = hit.Parent and hit.Parent:FindFirstChildOfClass("Humanoid")
		if humanoid then
			humanoid.Health = 0
		end
	end)
	cleanups[instance] = function()
		connection:Disconnect()
	end
end

local function onRemoved(instance: Instance)
	local cleanup = cleanups[instance]
	if cleanup then
		cleanup()
		cleanups[instance] = nil
	end
end

CollectionService:GetInstanceAddedSignal(TAG):Connect(onAdded)
CollectionService:GetInstanceRemovedSignal(TAG):Connect(onRemoved)
for _, instance in CollectionService:GetTagged(TAG) do
	task.spawn(onAdded, instance)
end

Configure components with attributes (instance:GetAttribute("Damage"), GetAttributeChangedSignal) instead of IntValue/StringValue children. Attributes replicate server → client, are cheaper, and show in the Properties panel.

Sharing state

NeedUse
Small per-instance/per-player values visible to clientsAttributes on the instance / Player (server sets).
Events and requestsRemoteEvent / UnreliableRemoteEvent (see roblox-networking).
Large or per-player private state (inventory, quests)Server-owned tables + remotes that send snapshots/diffs to that player only.
Same-side communicationModule function calls or a typed Signal module — not BindableEvent, _G, or shared.
Persistent dataroblox-data-stores. Cross-server: MessagingService / MemoryStore.

Streaming (on by default for new places)

With Workspace.StreamingEnabled, clients only have nearby parts. Client code must:

  • WaitForChild (with a timeout when it may never arrive) or nil-check anything in Workspace.
  • Use ModelStreamingMode = Atomic for models whose parts scripts need together;

Persistent only when a model must always be present (costs memory).

  • Treat GetChildren, raycasts, and property reads of streamed-out parts as partial/stale; do full-world

queries on the server.

  • Pre-stream destinations on the server with player:RequestStreamAroundAsync(position) before teleporting a character.
  • Scopes, racing, free cameras: player.FrustumStreaming = Enum.FrustumStreamingMode.Automatic streams what

the camera sees instead of raising the radius.

Full pattern catalog and recommended Workspace settings: references/streaming.md.

Anti-patterns

  • Dozens of loose Scripts inside parts/models (use tags + one service).
  • Polling loops (while task.wait(0.1) do check() end) instead of events or Heartbeat with deltaTime.
  • Trusting the client for game state, or firing remotes every frame.
  • _G/shared globals, circular requires, yielding at module top level.
  • Cloning maps into Workspace from the client (client-only copies never get server updates).
  • Storing per-player data in the character (it's destroyed on death).

Library ecosystem (signals, cleanup, networking, UI, ECS, data): references/ecosystem.md.

Related skills

roblox-networking, roblox-security, roblox-data-stores, roblox-tooling, roblox-performance, roblox-game-systems.

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
el4cteo
커뮤니티

roblox-audio

Sound and music - the Audio API (AudioPlayer, AudioEmitter, AudioListener, AudioDeviceOutput, Wire, effects, faders), classic Sound/SoundGroup, 2D vs 3D audio, music and SFX volume, client vs server playback, asset permissions, streaming caveats, voice routing, text-to-speech. Use when adding music, sound effects, spatial audio, mixing, or fixing sounds that don't play.

1시간 설치 수
5
GitHub Stars
131
업데이트
11월 17일
el4cteo
커뮤니티

roblox-characters-animation

Characters and animation - Humanoid properties/states, spawning (LoadCharacterAsync), health and damage, HumanoidDescription appearance, Animator/AnimationTrack playback, priorities and markers, default animation replacement, Tools, TweenService, IKControl, Character Controller Library (beta). Use when changing movement, abilities, damage, respawn, avatars, animations, tweens, or tools/weapons.

1시간 설치 수
5
GitHub Stars
131
업데이트
11월 17일
el4cteo
커뮤니티

roblox-code-review

Review Roblox/Luau code for exploits, data loss, memory leaks, performance problems, lifecycle bugs, policy issues, and deprecated or superseded APIs, using a severity-ranked checklist and the full 2026 deprecation map. Use when reviewing a PR or script, auditing a game before launch, modernizing legacy code, or asked what is wrong with some Roblox code.

1시간 설치 수
5
GitHub Stars
131
업데이트
11월 17일
el4cteo
커뮤니티

roblox-game-systems

Recipes for common systems built on server authority - currency service and leaderstats, XP/levels, round loops with intermission and teams, validated melee/ranged combat, inventory and tools, soft-currency shops, obby checkpoints, daily rewards, pets. Use when implementing or reviewing gameplay systems such as rounds, combat, weapons, inventories, shops, currencies, or progression.

1시간 설치 수
5
GitHub Stars
131
업데이트
11월 17일