url
stringlengths 20
126
| language
stringclasses 15
values | content
stringlengths 25
225k
| __index_level_0__
int64 0
19.6k
|
|---|---|---|---|
https://luau.org/getting-started
|
en-us
|
# Getting Started
#### On this page
* [Creating a script](#creating-a-script)
* [Type inference](#type-inference)
* [Annotations](#annotations)
* [Conclusions](#conclusions)
Luau is a fast, small, safe, gradually typed embeddable scripting language derived from Lua 5\.1\. Luau ships as a command line tool for running, analyzing, and linting your Luau scripts. Luau is integrated with RobloxStudio and is automatically enabled with the `--!strict` flag at the top of any scripts. Roblox developers should also visit our [Creator Docs Luau Section](https://create.roblox.com/docs/luau).
To get started with Luau you need to use `luau` command line binary to run your code and `luau-analyze` to run static analysis (including type checking and linting). You can download these from [a recent release](https://github.com/luau-lang/luau/releases).
## Creating a script[Permalink](#creating-a-script "Permalink")
To create your own testing script, create a new file with `.luau` as the extension:
```
function ispositive(x)
return x > 0
end
print(ispositive(1))
print(ispositive("2"))
function isfoo(a)
return a == "foo"
end
print(isfoo("bar"))
print(isfoo(1))
```
You can now run the file using `luau test.luau` and analyze it using `luau-analyze test.luau`.
Note that there are no warnings about calling `ispositive()` with a string, or calling `isfoo()` a number. This is because the type checking uses non\-strict mode by default, which is lenient in how it infers types used by the program.
## Type inference[Permalink](#type-inference "Permalink")
Now modify the script to include `--!strict` at the top:
```
--!strict
function ispositive(x)
return x > 0
end
print(ispositive(1))
print(ispositive("2"))
```
In `strict` mode, Luau will infer types based on analysis of the code flow. There is also `nonstrict` mode, where analysis is more conservative and types are more frequently inferred as `any` to reduce cases where legitimate code is flagged with warnings.
In this case, Luau will use the `return x > 0` statement to infer that `ispositive()` is a function taking a number and returning a boolean. Note that in this case, it was not necessary to add any explicit type annotations.
Based on Luau’s type inference, the analysis tool will now flag the incorrect call to `ispositive()`:
```
$ luau-analyze test.luau
test.luau(7,18): TypeError: Type 'string' could not be converted into 'number'
```
## Annotations[Permalink](#annotations "Permalink")
You can add annotations to locals, arguments, and function return types. Among other things, annotations can help enforce that you don’t accidentally do something silly. Here’s how we would add annotations to `ispositive()`:
```
--!strict
function ispositive(x : number) : boolean
return x > 0
end
local result : boolean
result = ispositive(1)
```
Now we’ve explicitly told Luau that `ispositive()` accepts a number and returns a boolean. This wasn’t strictly (pun intended) necessary in this case, because Luau’s inference was able to deduce this already. But even in this case, there are advantages to explicit annotations. Imagine that later we decide to change `ispositive()` to return a string value:
```
--!strict
function ispositive(x : number) : boolean
if x > 0 then
return "yes"
else
return "no"
end
end
local result : boolean
result = ispositive(1)
```
Oops – we’re returning string values, but we forgot to update the function return type. Since we’ve told Luau that `ispositive()` returns a boolean (and that’s how we’re using it), the call site isn’t flagged as an error. But because the annotation doesn’t match our code, we get a warning in the function body itself:
```
$ luau-analyze test.luau
test.luau(5,9): TypeError: Type 'string' could not be converted into 'boolean'
test.luau(7,9): TypeError: Type 'string' could not be converted into 'boolean'
```
The fix is simple; just change the annotation to declare the return type as a string:
```
--!strict
function ispositive(x : number) : string
if x > 0 then
return "yes"
else
return "no"
end
end
local result : boolean
result = ispositive(1)
```
Well, almost \- since we declared `result` as a boolean, the call site is now flagged:
```
$ luau-analyze test.luau
test.luau(12,10): TypeError: Type 'string' could not be converted into 'boolean'
```
If we update the type of the local variable, everything is good. Note that we could also just let Luau infer the type of `result` by changing it to the single line version `local result = ispositive(1)`.
```
--!strict
function ispositive(x : number) : string
if x > 0 then
return "yes"
else
return "no"
end
end
local result : string
result = ispositive(1)
```
## Conclusions[Permalink](#conclusions "Permalink")
This has been a brief tour of the basic functionality of Luau, but there’s lots more to explore. If you’re interested in reading more, check out our main reference pages for <syntax> and [typechecking](typecheck).
| 0 |
https://luau.org/why
|
en-us
|
# Why Luau?
Around 2006, [Roblox](https://www.roblox.com) started using Lua 5\.1 as a scripting language for games. Over the years the runtime had to be tweaked to provide a safe, secure sandboxed environment; we gradually started accumulating small library changes and tweaks.
Over the course of the last few years, instead of using Web\-based stack for our player\-facing application, Lua\-based in\-game UI and Qt\-based editor UI, we’ve started consolidating a lot of the efforts and developing all of these using Roblox engine and Lua as a scripting language.
Having grown a substantial internal codebase that needed to be correct and performant, and with the focus shifting a bit from novice game developers to professional studios building games on Roblox and our own teams of engineers building applications, there was a need to improve performance and quality of the code we were writing.
Unlike mainline Lua, we also could not afford to do major breaking changes to the language (hence the 5\.1 language baseline that remained unchanged for more than a decade). While faster implementations of Lua 5\.1 like LuaJIT were available, they didn’t meet our needs in terms of portability, ease of change and they didn’t address the problem of developing robust code at scale.
All of these motivated us to start reshaping Lua 5\.1 that we started from into a new, derivative language that we call Luau. Our focus is on making the language more performant and feature\-rich, and make it easier to write robust code through a combination of linting and type checking using a gradual type system.
## Complete rewrite?[Permalink](#complete-rewrite "Permalink")
A very large part of Luau codebase is written from scratch. We needed a set of tools to be able to write language analysis tools; Lua has a parser that is integrated with the bytecode compiler, which makes it unsuitable for complex semantic analysis. For bytecode compilation, while a single pass compiler can deliver better compilation throughput and be simpler than a full frontend/backend, it significantly limits the optimizations that can be done at the bytecode level.
Luau compiler and analysis tools are thus written from scratch, closely following the syntax and semantics of Lua. Our compiler is not single\-pass, and instead relies on a set of analysis passes that run over the AST to produce efficient bytecode, followed by some post\-process optimizations.
As for the runtime, we had to rewrite the interpreter from scratch to get substantially faster performance; using a combination of techniques pioneered by LuaJIT and custom optimizations that are able to improve performance by taking control over the entire stack (language, compiler, interpreter, virtual machine), we’re able to get close to LuaJIT interpreter performance while using C as an implementation language.
The garbage collector and the core libraries represent more of an incremental change, where we used Lua 5\.1 as a baseline but we’re continuing to rewrite these as well with performance in mind.
While Luau initially didn’t include a JIT/AOT, native code generation has since been implemented for x64/arm64 platform as an optional component.
| 1 |
https://luau.org/syntax
|
en-us
|
# Syntax
#### On this page
* [String literals](#string-literals)
* [Number literals](#number-literals)
* [Continue statement](#continue-statement)
* [Compound assignments](#compound-assignments)
* [Type annotations](#type-annotations)
* [If\-then\-else expressions](#if-then-else-expressions)
* [Generalized iteration](#generalized-iteration)
* [String interpolation](#string-interpolation)
+ [Restrictions and limitations](#restrictions-and-limitations)
* [Floor division (//)](#floor-division-)
Luau uses the baseline [syntax of Lua 5\.1](https://www.lua.org/manual/5.1/manual.html#2). For detailed documentation, please refer to the Lua manual, this is an example:
```
local function tree_insert(tree, x)
local lower, equal, greater = split(tree.root, x)
if not equal then
equal = {
x = x,
y = math.random(0, 2^31-1),
left = nil,
right = nil
}
end
tree.root = merge3(lower, equal, greater)
end
```
Note that future versions of Lua extend the Lua 5\.1 syntax with more features; Luau does support string literal extensions but does not support other 5\.x additions; for details please refer to [compatibility section](compatibility).
The rest of this document documents additional syntax used in Luau.
## String literals[Permalink](#string-literals "Permalink")
Luau implements support for hexadecimal (`\x`), Unicode (`\u`) and `\z` escapes for string literals. This syntax follows [Lua 5\.3 syntax](https://www.lua.org/manual/5.3/manual.html#3.1):
* `\xAB` inserts a character with the code 0xAB into the string
* `\u{ABC}` inserts a UTF8 byte sequence that encodes U\+0ABC character into the string (note that braces are mandatory)
* `\z` at the end of the line inside a string literal ignores all following whitespace including newlines, which can be helpful for breaking long literals into multiple lines.
## Number literals[Permalink](#number-literals "Permalink")
In addition to basic integer and floating\-point decimal numbers, Luau supports:
* Hexadecimal integer literals, `0xABC` or `0XABC`
* Binary integer literals, `0b01010101` or `0B01010101`
* Decimal separators in all integer literals, using `_` for readability: `1_048_576`, `0xFFFF_FFFF`, `0b_0101_0101`
Note that Luau only has a single number type, a 64\-bit IEEE754 double precision number (which can represent integers up to 2^53 exactly), and larger integer literals are stored with precision loss.
## Continue statement[Permalink](#continue-statement "Permalink")
In addition to `break` in all loops, Luau supports `continue` statement. Similar to `break`, `continue` must be the last statement in the block.
Note that unlike `break`, `continue` is not a keyword. This is required to preserve backwards compatibility with existing code; so this is a `continue` statement:
```
if x < 0 then
continue
end
```
Whereas this is a function call:
```
if x < 0 then
continue()
end
```
When used in `repeat..until` loops, `continue` can not skip the declaration of a local variable if that local variable is used in the loop condition; code like this is invalid and won’t compile:
```
repeat
do continue end
local a = 5
until a > 0
```
## Compound assignments[Permalink](#compound-assignments "Permalink")
Luau supports compound assignments with the following operators: `+=`, `-=`, `*=`, `/=`, `//=`, `%=`, `^=`, `..=`. Just like regular assignments, compound assignments are statements, not expressions:
```
-- this works
a += 1
-- this doesn't work
print(a += 1)
```
Compound assignments only support a single value on the left and right hand side; additionally, the function calls on the left hand side are only evaluated once:
```
-- calls foo() twice
a[foo()] = a[foo()] + 1
-- calls foo() once
a[foo()] += 1
```
Compound assignments call the arithmetic metamethods (`__add` et al) and table indexing metamethods (`__index` and `__newindex`) as needed \- for custom types no extra effort is necessary to support them.
## Type annotations[Permalink](#type-annotations "Permalink")
To support gradual typing, Luau supports optional type annotations for variables and functions, as well as declaring type aliases.
Types can be declared for local variables, function arguments and function return types using `:` as a separator:
```
function foo(x: number, y: string): boolean
local k: string = y:rep(x)
return k == "a"
end
```
In addition, the type of any expression can be overridden using a type cast `::`:
```
local k = (y :: string):rep(x)
```
There are several simple builtin types: `any` (represents inability of the type checker to reason about the type), `nil`, `boolean`, `number`, `string` and `thread`.
Function types are specified using the arguments and return types, separated with `->`:
```
local foo: (number, string) -> boolean
```
To return no values or more than one, you need to wrap the return type position with parentheses, and then list your types there.
```
local no_returns: (number, string) -> ()
local returns_boolean_and_string: (number, string) -> (boolean, string)
function foo(x: number, y: number): (number, string)
return x + y, tostring(x) .. tostring(y)
end
```
Note that function types are specified without the argument names in the examples above, but it’s also possible to specify the names (that are not semantically significant but can show up in documentation and autocomplete):
```
local callback: (errorCode: number, errorText: string) -> ()
```
Table types are specified using the table literal syntax, using `:` to separate keys from values:
```
local array: { [number] : string }
local object: { x: number, y: string }
```
When the table consists of values keyed by numbers, it’s called an array\-like table and has a special short\-hand syntax, `{T}` (e.g. `{string}`).
Additionally, the type syntax supports type intersections (`((number) -> string) & ((boolean) -> string)`) and unions (`(number | boolean) -> string`). An intersection represents a type with values that conform to both sides at the same time, which is useful for overloaded functions; a union represents a type that can store values of either type \- `any` is technically a union of all possible types.
It’s common in Lua for function arguments or other values to store either a value of a given type or `nil`; this is represented as a union (`number | nil`), but can be specified using `?` as a shorthand syntax (`number?`).
In addition to declaring types for a given value, Luau supports declaring type aliases via `type` syntax:
```
type Point = { x: number, y: number }
type Array<T> = { [number]: T }
type Something = typeof(string.gmatch("", "%d"))
```
The right hand side of the type alias can be a type definition or a `typeof` expression; `typeof` expression doesn’t evaluate its argument at runtime.
By default type aliases are local to the file they are declared in. To be able to use type aliases in other modules using `require`, they need to be exported:
```
export type Point = { x: number, y: number }
```
An exported type can be used in another module by prefixing its name with the require alias that you used to import the module.
```
local M = require(Other.Module)
local a: M.Point = {x=5, y=6}
```
For more information please refer to [typechecking documentation](typecheck).
## If\-then\-else expressions[Permalink](#if-then-else-expressions "Permalink")
In addition to supporting standard if *statements*, Luau adds support for if *expressions*. Syntactically, `if-then-else` expressions look very similar to if statements. However instead of conditionally executing blocks of code, if expressions conditionally evaluate expressions and return the value produced as a result. Also, unlike if statements, if expressions do not terminate with the `end` keyword.
Here is a simple example of an `if-then-else` expression:
```
local maxValue = if a > b then a else b
```
`if-then-else` expressions may occur in any place a regular expression is used. The `if-then-else` expression must match `if <expr> then <expr> else <expr>`; it can also contain an arbitrary number of `elseif` clauses, like `if <expr> then <expr> elseif <expr> then <expr> else <expr>`. Note that in either case, `else` is mandatory.
Here’s is an example demonstrating `elseif`:
```
local sign = if x < 0 then -1 elseif x > 0 then 1 else 0
```
**Note:** In Luau, the `if-then-else` expression is preferred vs the standard Lua idiom of writing `a and b or c` (which roughly simulates a ternary operator). However, the Lua idiom may return an unexpected result if `b` evaluates to false. The `if-then-else` expression will behave as expected in all situations.
## Generalized iteration[Permalink](#generalized-iteration "Permalink")
Luau uses the standard Lua syntax for iterating through containers, `for vars in values`, but extends the semantics with support for generalized iteration. In Lua, to iterate over a table you need to use an iterator like `next` or a function that returns one like `pairs` or `ipairs`. In Luau, you can simply iterate over a table:
```
for k, v in {1, 4, 9} do
assert(k * k == v)
end
```
Further, iteration can be extended for tables or userdata by implementing the `__iter` metamethod which is called before the iteration begins, and should return an iterator function like `next` (or a custom one):
```
local obj = { items = {1, 4, 9} }
setmetatable(obj, { __iter = function(o) return next, o.items end })
for k, v in obj do
assert(k * k == v)
end
```
The default iteration order for tables is specified to be consecutive for elements `1..#t` and unordered after that, visiting every element; similarly to iteration using `pairs`, modifying the table entries for keys other than the current one results in unspecified behavior.
## String interpolation[Permalink](#string-interpolation "Permalink")
Luau adds an additional way to define string values that allows you to place runtime expressions directly inside specific spots of the literal.
This is a more ergonomic alternative over using `string.format` or `("literal"):format`.
To use string interpolation, use a backtick string literal:
```
local count = 3
print(`Bob has {count} apple(s)!`)
--> Bob has 3 apple(s)!
```
Any expression can be used inside `{}`:
```
local combos = {2, 7, 1, 8, 5}
print(`The lock combination is {table.concat(combos)}.`)
--> The lock combination is 27185.
```
Inside backtick string literal, `\` is used to escape ```, `{`, `\` itself and a newline:
```
print(`Some example escaping the braces \{like so}`)
--> Some example escaping the braces {like so}
print(`Backslash \ that escapes the space is not a part of the string...`)
--> Backslash that escapes the space is not a part of the string...
print(`Backslash \\ will escape the second backslash...`)
--> Backslash \ will escape the second backslash...
print(`Some text that also includes \`...`)
--> Some text that also includes `...
local name = "Luau"
print(`Welcome to {
name
}!`)
--> Welcome to Luau!
```
### Restrictions and limitations[Permalink](#restrictions-and-limitations "Permalink")
The sequence of two opening braces `{{` is rejected with a parse error.
This restriction is made to prevent developers using other programming languages with a similar feature from trying to attempt that as a way to escape a single `{` and getting unexpected results in Luau.
Luau currently does not support backtick string literals in type annotations, therefore `type Foo = `Foo`` is invalid syntax.
Unlike single and double\-quoted string literals, backtick string literals must always be wrapped in parentheses for function calls:
```
print "hello" -- valid
print`hello` -- invalid syntax
print(`hello`) -- valid
```
## Floor division (`//`)[Permalink](#floor-division- "Permalink")
Luau supports floor division, including its operator (`//`), its compound assignment operator (`//=`), and overloading metamethod (`__idiv`), as an ergonomic alternative to `math.floor`.
For numbers, `a // b` is equal to `math.floor(a / b)`:
```
local n = 6.72
print(n // 2) --> 3
n //= 3
print(n) --> 2
```
Note that it’s possible to get `inf`, `-inf`, or `NaN` with floor division; when `b` is `0`, `a // b` results in positive or negative infinity, and when both `a` and `b` are `0`, `a // b` results in NaN.
For native vectors, `c // d` applies `math.floor` to each component of the vector `c`. Therefore `c // d` is equivalent to `vector.create(math.floor(c.x / d), math.floor(c.y / b), math.floor(c.z / b))`.
Floor division syntax and semantics follow from [Lua 5\.3](https://www.lua.org/manual/5.3/manual.html#3.4.1) where applicable.
| 2 |
https://luau.org/lint
|
en-us
|
# Linting
#### On this page
* [UnknownGlobal (1\)](#unknownglobal-1)
* [DeprecatedGlobal (2\)](#deprecatedglobal-2)
* [GlobalUsedAsLocal (3\)](#globalusedaslocal-3)
* [LocalShadow (4\)](#localshadow-4)
* [SameLineStatement (5\)](#samelinestatement-5)
* [MultiLineStatement (6\)](#multilinestatement-6)
* [LocalUnused (7\)](#localunused-7)
* [FunctionUnused (8\)](#functionunused-8)
* [ImportUnused (9\)](#importunused-9)
* [BuiltinGlobalWrite (10\)](#builtinglobalwrite-10)
* [PlaceholderRead (11\)](#placeholderread-11)
* [UnreachableCode (12\)](#unreachablecode-12)
* [UnknownType (13\)](#unknowntype-13)
* [ForRange (14\)](#forrange-14)
* [UnbalancedAssignment (15\)](#unbalancedassignment-15)
* [ImplicitReturn (16\)](#implicitreturn-16)
* [DuplicateLocal (17\)](#duplicatelocal-17)
* [FormatString (18\)](#formatstring-18)
* [TableLiteral (19\)](#tableliteral-19)
* [UninitializedLocal (20\)](#uninitializedlocal-20)
* [DuplicateFunction (21\)](#duplicatefunction-21)
* [DeprecatedApi (22\)](#deprecatedapi-22)
* [TableOperations (23\)](#tableoperations-23)
* [DuplicateCondition (24\)](#duplicatecondition-24)
* [MisleadingAndOr (25\)](#misleadingandor-25)
* [CommentDirective (26\)](#commentdirective-26)
* [IntegerParsing (27\)](#integerparsing-27)
* [ComparisonPrecedence (28\)](#comparisonprecedence-28)
Luau comes with a set of linting passes, that help make sure that the code is correct and consistent. Unlike the type checker, that models the behavior of the code thoroughly and points toward type mismatches that are likely to result in runtime errors, the linter is more opinionated and produces warnings that can often be safely ignored, although it’s recommended to keep the code clean of the warnings.
Linter produces many different types of warnings; many of these are enabled by default, and can be suppressed by declaring `--!nolint NAME` at the top of the file. In dire situations `--!nolint` at the top of the file can be used to completely disable all warnings (note that the type checker is still active, and requires a separate `--!nocheck` declaration).
The rest of this page documents all warnings produced by the linter; each warning has a name and a numeric code, the latter is used when displaying warnings.
## UnknownGlobal (1\)[Permalink](#unknownglobal-1 "Permalink")
By default, variables in Luau are global (this is inherited from Lua 5\.x and can’t be changed because of backwards compatibility). This means that typos in identifiers are invisible to the parser, and often break at runtime. For this reason, the linter considers all globals that aren’t part of the builtin global table and aren’t explicitly defined in the script “unknown”:
```
local displayName = "Roblox"
-- Unknown global 'displaName'
print(displaName)
```
Note that injecting globals via `setfenv` can produce this warning in correct code; global injection is incompatible with type checking and has performance implications so we recommend against it and in favor of using `require` with correctly scoped identifiers.
## DeprecatedGlobal (2\)[Permalink](#deprecatedglobal-2 "Permalink")
Some global names exist for compatibility but their use is discouraged. This mostly affects globals introduced by Roblox, and since they can have problematic behavior or can break in the future, this warning highlights their uses:
```
-- Global 'ypcall' is deprecated, use 'pcall' instead
ypcall(function()
print("hello")
end)
```
## GlobalUsedAsLocal (3\)[Permalink](#globalusedaslocal-3 "Permalink")
The UnknownGlobal lint can catch typos in globals that are read, but can’t catch them in globals that are assigned to. Because of this, and to discourage the use of globals in general, linter detects cases when a global is only used in one function and can be safely converted to a local variable. Note that in some cases this requires declaring the local variable in the beginning of the function instead of where it’s being assigned to.
```
local function testFunc(a)
if a < 5 then
-- Global 'b' is only used in the enclosing function; consider changing it to local
b = 1
else
b = 2
end
print(b)
end
```
## LocalShadow (4\)[Permalink](#localshadow-4 "Permalink")
In Luau, it is valid to shadow locals and globals with a local variable, including doing it in the same function. This can result in subtle bugs, since the shadowing may not be obvious to the reader. This warning detects cases where local variables shadow other local variables in the same function, or global variables used in the script; for more cases of detected shadowing see `LocalShadowPedantic`.
```
local function foo()
for i=1,10 do
-- Variable 'i' shadows previous declaration at line 2
for i=1,10 do
print(i)
end
end
end
```
## SameLineStatement (5\)[Permalink](#samelinestatement-5 "Permalink")
Luau doesn’t require the use of semicolons and doesn’t automatically insert them at line breaks. When used wisely this results in code that is easy to read and understand, however it can cause subtle issues and hard to understand code when abused by using many different statements on the same line. This warning highlights cases where code should either be broken into multiple lines, or use `;` as a visual guide.
```
-- A new statement is on the same line; add semi-colon on previous statement to silence
if b < 0 then local a = b + 1 print(a, b) end
```
## MultiLineStatement (6\)[Permalink](#multilinestatement-6 "Permalink")
An opposite problem is having statements that span multiple lines. This is good for readability when the code is indented properly, but when it’s not it results in code that’s hard to understand, as its easy to confuse the next line for a separate statement.
```
-- Statement spans multiple lines; use indentation to silence
print(math.max(1,
math.min(2, 3)))
```
## LocalUnused (7\)[Permalink](#localunused-7 "Permalink")
This warning is one of the few warnings that highlight unused variables. Local variable declarations that aren’t used may indicate a bug in the code (for example, there could be a typo in the code that uses the wrong variable) or redundant code that is no longer necessary (for example, calling a function to get its result and never using this result). This warning warns about locals that aren’t used; if the locals are not used intentionally they can be prefixed with `_` to silence the warning:
```
local x = 1
-- Variable 'y' is never used; prefix with '_' to silence
local y = 2
print(x, x)
```
## FunctionUnused (8\)[Permalink](#functionunused-8 "Permalink")
While unused local variables could be useful for debugging, unused functions usually contain dead code that was meant to be removed. Unused functions clutter code, can be a result of typos similar to local variables, and can mislead the reader into thinking that some functionality is supported.
```
-- Function 'bar' is never used; prefix with '_' to silence
local function bar()
end
local function foo()
end
return foo()
```
## ImportUnused (9\)[Permalink](#importunused-9 "Permalink")
In Luau, there’s no first\-class module system that’s part of the syntax, but `require` function acts as an import statement. When a local is initialized with a `require` result, and the local is unused, this is classified as “unused import”. Removing unused imports improves code quality because it makes it obvious what the dependencies of the code are:
```
-- Import 'Roact' is never used; prefix with '_' to silence
local Roact = require(game.Packages.Roact)
```
## BuiltinGlobalWrite (10\)[Permalink](#builtinglobalwrite-10 "Permalink")
While the sandboxing model of Luau prevents overwriting built\-in globals such as `table` for the entire program, it’s still valid to reassign these globals \- this results in “global shadowing”, where the script’s global table contains a custom version of `table` after writing to it. This is problematic because it disables some optimizations, and can result in misleading code. When shadowing built\-in globals, use locals instead.
```
-- Built-in global 'math' is overwritten here; consider using a local or changing the name
math = {}
```
## PlaceholderRead (11\)[Permalink](#placeholderread-11 "Permalink")
`_` variable name is commonly used as a placeholder to discard function results. The linter follows this convention and doesn’t warn about the use of `_` in various cases where a different name would cause a warning otherwise. To make sure the placeholder is only used to write values to it, this warning detects the cases where it’s read instead:
```
local _ = 5
-- Placeholder value '_' is read here; consider using a named variable
return _
```
## UnreachableCode (12\)[Permalink](#unreachablecode-12 "Permalink")
In some cases the linter can detect code that is never executed, because all execution paths through the function exit the function or the loop before reaching it. Such code is misleading because it’s not always obvious to the reader that it never runs, and as such it should be removed.
```
function cbrt(v)
if v >= 0 then
return v ^ (1/3)
else
error('cbrt expects a non-negative argument')
end
-- Unreachable code (previous statement always returns)
return 0
end
```
## UnknownType (13\)[Permalink](#unknowntype-13 "Permalink")
Luau provides several functions to get the value type as a string (`type`, `typeof`), and some Roblox APIs expose class names through string arguments (`Instance.new`). This warning detects incorrect use of the type names by checking the string literals used in type comparisons and function calls.
```
-- Unknown type 'String' (expected primitive type)
if type(v) == "String" then
print("v is a string")
end
```
## ForRange (14\)[Permalink](#forrange-14 "Permalink")
When using a numeric for, it’s possible to make various mistakes when specifying the for bounds. For example, to iterate through the table backwards, it’s important to specify the negative step size. This warning detects several cases where the numeric for only runs for 0 or 1 iterations, or when the step doesn’t divide the size of the range evenly.
```
-- For loop should iterate backwards; did you forget to specify -1 as step?
for i=#t,1 do
end
```
## UnbalancedAssignment (15\)[Permalink](#unbalancedassignment-15 "Permalink")
Assignment statements and local variable declarations in Luau support multiple variables on the left side and multiple values on the right side. The number of values doesn’t need to match; when the right side has more values, the extra values are discarded, and then the left side has more variables the extra variables are set to `nil`. However, this can result in subtle bugs where a value is omitted mistakenly. This warning warns about cases like this; if the last expression on the right hand side returns multiple values, the warning is not emitted.
```
-- Assigning 2 values to 3 variables initializes extra variables with nil; add 'nil' to value list to silence
local x, y, z = 1, 2
```
## ImplicitReturn (16\)[Permalink](#implicitreturn-16 "Permalink")
In Luau, there’s a subtle difference between returning no values from a function and returning `nil`. In many contexts these are equivalent, but when the results are passed to a variadic function (perhaps implicitly), the difference can be observed \- for example, `print(foo())` prints nothing if `foo` returns no values, and `nil` if it returns `nil`.
To help write code that has consistent behavior, linter warns about cases when a function implicitly returns no values, if there are cases when it explicitly returns a result. For code like this it’s recommended to use explicit `return` or `return nil` at the end of the function (these have different semantics, so the correct version to use depends on the function):
```
local function find(t, expected)
for k,v in pairs(t) do
if k == expected then
return v
end
end
-- Function 'find' can implicitly return no values even though there's an explicit return at line 4; add explicit return to silence
end
```
## DuplicateLocal (17\)[Permalink](#duplicatelocal-17 "Permalink")
Luau syntax allows to use the same name for different parameters of a function as well as different local variables declared in the same statement. This is error prone, even if it’s occasionally useful, so a warning is emitted in cases like this, unless the duplicate name is the placeholder `_`:
```
function foo(a, b, a) -- Function parameter 'a' already defined on column 14
end
function obj:method(self) -- Function parameter 'self' already defined implicitly
end
local x, y, x = v:GetComponents() -- Variable 'x' already defined on column 7
```
## FormatString (18\)[Permalink](#formatstring-18 "Permalink")
Luau has several library functions that expect a format string that specifies the behavior for the function. These format strings follow a specific syntax that depends on the question; mistakes in these strings can lead to runtime errors or unexpected behavior of the code.
To help make sure that the strings used for these functions are correct, linter checks calls to `string.format`, `string.pack`, `string.packsize`, `string.unpack`, `string.match`, `string.gmatch`, `string.find`, `string.gsub` and `os.date` and issues warnings when the call uses a literal string with an incorrect format:
```
-- Invalid match pattern: invalid capture reference, must refer to a closed capture
local cap = string.match(s, "(%d)%2")
-- Invalid format string: unfinished format specifier
local str = ("%d %"):format(1, 2)
```
Note that with the exception of `string.format` this only works when the function is called via the library, not via the method call (so prefer `string.match(s, "pattern")` to `s:match("pattern")`).
## TableLiteral (19\)[Permalink](#tableliteral-19 "Permalink")
Table literals are often used in Luau to create objects or specify data. The syntax for table literals is rich but invites mistakes, for example it allows duplicate keys or redundant index specification for values already present in the list form. This warning is emitted for cases where some entries in the table literal are ignored at runtime as they’re duplicate:
```
print({
first = 1,
second = 2,
first = 3, -- Table field 'first' is a duplicate; previously defined at line 2
})
```
## UninitializedLocal (20\)[Permalink](#uninitializedlocal-20 "Permalink")
It’s easy to forget to initialize a local variable and then proceed to use it regardless. This can happen due to a typo, or sometimes it can happen because the original variable definition is shadowed. When a local variable doesn’t have an initial value and is used without ever being assigned to, this warning is emitted:
```
local foo
if foo then -- Variable 'foo' defined at line 1 is never initialized or assigned; initialize with 'nil' to silence
print(foo)
end
```
## DuplicateFunction (21\)[Permalink](#duplicatefunction-21 "Permalink")
This warning is emitted when a script defines two functions with the same name in the same scope.
The warning is not produced when the functions are defined in different scopes because this is much more likely to be intentional.
```
function foo() end
function foo() end -- Duplicate function definition: 'foo' also defined on line 1
-- OK: the functions are not defined in the same scope.
if x then
function bar() end
else
function bar() end
end
```
## DeprecatedApi (22\)[Permalink](#deprecatedapi-22 "Permalink")
This warning is emitted when a script accesses a method or field that is marked as deprecated. Use of deprecated APIs is discouraged since they may have performance or correctness issues, may result in unexpected behavior, and could be removed in the future.
```
function getSize(i: Instance)
return i.DataCost -- Member 'Instance.DataCost' is deprecated
end
```
## TableOperations (23\)[Permalink](#tableoperations-23 "Permalink")
To manipulate array\-like tables, Luau provides a set of functions as part of the standard `table` library. To help use these functions correctly, this warning is emitted when one of these functions is used incorrectly or can be adjusted to be more performant.
```
local t = {}
table.insert(t, 0, 42) -- table.insert uses index 0 but arrays are 1-based; did you mean 1 instead?
table.insert(t, #t+1, 42) -- table.insert will append the value to the table; consider removing the second argument for efficiency
```
In addition, when type information is present, this warning will be emitted when `#` or `ipairs` is used on a table that has no numeric keys or indexers. This helps avoid common bugs like using `#t == 0` to check if a dictionary is empty.
```
local message = { data = { 1, 2, 3 } }
if #message == 0 then -- Using '#' on a table without an array part is likely a bug
end
```
## DuplicateCondition (24\)[Permalink](#duplicatecondition-24 "Permalink")
When checking multiple conditions via `and/or` or `if/elseif`, a copy \& paste error may result in checking the same condition redundantly. This almost always indicates a bug, so a warning is emitted when use of a duplicate condition is detected.
```
assert(self._adorns[normID1] and self._adorns[normID1]) -- Condition has already been checked on column 8
```
## MisleadingAndOr (25\)[Permalink](#misleadingandor-25 "Permalink")
In Lua, there is no first\-class ternary operator but it can be emulated via `a and b or c` pattern. However, due to how boolean evaluation works, if `b` is `false` or `nil`, the resulting expression evaluates to `c` regardless of the value of `a`. Luau solves this problem with the `if a then b else c` expression; a warning is emitted for and\-or expressions where the first alternative is `false` or `nil` because it’s almost always a bug.
```
-- The and-or expression always evaluates to the second alternative because the first alternative is false; consider using if-then-else expression instead
local x = flag and false or true
```
The code above can be rewritten as follows to avoid the warning and the associated bug:
```
local x = if flag then false else true
```
## CommentDirective (26\)[Permalink](#commentdirective-26 "Permalink")
Luau uses comments that start from `!` to control certain aspects of analysis, for example setting type checking mode via `--!strict` or disabling individual lints with `--!nolint`. Unknown directives are ignored, for example `--!nostrict` doesn’t have any effect on the type checking process as the correct spelling is `--!nonstrict`. This warning flags comment directives that are ignored during processing:
```
--!nostrict
-- Unknown comment directive 'nostrict'; did you mean 'nonstrict'?"
```
## IntegerParsing (27\)[Permalink](#integerparsing-27 "Permalink")
Luau parses hexadecimal and binary literals as 64\-bit integers before converting them to Luau numbers. As a result, numbers that exceed 2^64 are silently truncated to 2^64, which can result in unexpected program behavior. This warning flags literals that are truncated:
```
-- Hexadecimal number literal exceeded available precision and was truncated to 2^64
local x = 0x1111111111111111111111111111111111111
```
Luau numbers are represented as double precision IEEE754 floating point numbers; they can represent integers up to 2^53 exactly, but larger integers may lose precision. This warning also flags literals that are parsed with a precision loss:
```
-- Number literal exceeded available precision and was truncated to closest representable number
local x = 9007199254740993
```
## ComparisonPrecedence (28\)[Permalink](#comparisonprecedence-28 "Permalink")
Because of operator precedence rules, not X \=\= Y parses as (not X) \=\= Y; however, often the intent was to invert the result of the comparison. This warning flags erroneous conditions like that, as well as flagging cases where two comparisons happen in a row without any parentheses:
```
-- not X == Y is equivalent to (not X) == Y; consider using X ~= Y, or wrap one of the expressions in parentheses to silence
if not x == 5 then
end
-- X <= Y <= Z is equivalent to (X <= Y) <= Z; wrap one of the expressions in parentheses to silence
if 1 <= x <= 3 then
end
```
| 3 |
https://luau.org/performance
|
en-us
|
# Performance
#### On this page
* [Fast bytecode interpreter](#fast-bytecode-interpreter)
* [Optimizing compiler](#optimizing-compiler)
* [Epsilon\-overhead debugger](#epsilon-overhead-debugger)
* [Inline caching for table and global access](#inline-caching-for-table-and-global-access)
* [Importing global access chains](#importing-global-access-chains)
* [Fast method calls](#fast-method-calls)
* [Specialized builtin function calls](#specialized-builtin-function-calls)
* [Optimized table iteration](#optimized-table-iteration)
* [Optimized table length](#optimized-table-length)
* [Creating and modifying tables](#creating-and-modifying-tables)
* [Native vector math](#native-vector-math)
* [Optimized upvalue storage](#optimized-upvalue-storage)
* [Closure caching](#closure-caching)
* [Fast memory allocator](#fast-memory-allocator)
* [Optimized libraries](#optimized-libraries)
* [Improved garbage collector pacing](#improved-garbage-collector-pacing)
* [Reduced garbage collector pauses](#reduced-garbage-collector-pauses)
* [Optimized garbage collector sweeping](#optimized-garbage-collector-sweeping)
* [Function inlining and loop unrolling](#function-inlining-and-loop-unrolling)
One of main goals of Luau is to enable high performance code, with gameplay code being the main use case. This can be viewed as two separate goals:
* Make idiomatic code that wasn’t tuned faster
* Enable even higher performance through careful tuning
Both of these goals are important \- it’s insufficient to just focus on the highly tuned code, and all things being equal we prefer to raise all boats by implementing general optimizations. However, in some cases it’s important to be aware of optimizations that Luau does and doesn’t do.
Worth noting is that Luau is focused on, first and foremost, stable high performance code in interpreted context. This is because JIT compilation is not available on many platforms Luau runs on, and AOT compilation would only work for code that Roblox ships (and even that does not always work). This is in stark contrast with LuaJIT that, while providing an excellent interpreter as well, focuses a lot of the attention on JIT (with many optimizations unavailable in the interpreter).
Having said that, Luau has been updated to include an optional JIT component for x64 and arm64 platforms. This component can compile a selected set of functions, including limiting compilation to functions or modules marked explicitly by the user. While functions can be compiled at any time, automated JIT compilation decisions based on statistics/tracing are not performed. Luau JIT takes into account the type annotations present in the source code to specialize code paths and at this time, doesn’t include runtime analysis of the types/values flowing through the program.
The rest of this document goes into some optimizations that Luau employs and how to best leverage them when writing code. The document is not complete \- a lot of optimizations are transparent to the user and involve detailed low\-level tuning of various parts that is not described here \- and all of this is subject to change without notice, as it doesn’t affect the semantics of valid code.
## Fast bytecode interpreter[Permalink](#fast-bytecode-interpreter "Permalink")
Luau features a very highly tuned portable bytecode interpreter. It’s similar to Lua interpreter in that it’s written in C, but it’s highly tuned to yield efficient assembly when compiled with Clang and latest versions of MSVC. On some workloads it can match the performance of LuaJIT interpreter which is written in highly specialized assembly. We are continuing to tune the interpreter and the bytecode format over time; while extra performance can be extracted by rewriting the interpreter in assembly, we’re unlikely to ever do that as the extra gains at this point are marginal, and we gain a lot from C in terms of portability and being able to quickly implement new optimizations.
Of course the interpreter isn’t typical C code \- it uses many tricks to achieve extreme levels of performance and to coerce the compiler to produce efficient assembly. Due to a better bytecode design and more efficient dispatch loop it’s noticeably faster than Lua 5\.x (including Lua 5\.4 which made some of the changes similar to Luau, but doesn’t come close). The bytecode design was partially inspired by excellent LuaJIT interpreter. Most computationally intensive scripts only use the interpreter core loop and builtins, which on x64 compiles into \~16 KB, thus leaving half of the instruction cache for other infrequently called code.
## Optimizing compiler[Permalink](#optimizing-compiler "Permalink")
Unlike Lua and LuaJIT, Luau uses a multi\-pass compiler with a frontend that parses source into an AST and a backend that generates bytecode from it. This carries a small penalty in terms of compilation time, but results in more flexible code and, crucially, makes it easier to optimize the generated bytecode.
> Note: Compilation throughput isn’t the main focus in Luau, but our compiler is reasonably fast; with all currently implemented optimizations enabled, it compiles 950K lines of Luau code in 1 second on a single core of a desktop Ryzen 5900X CPU, producing bytecode and debug information.
While bytecode optimizations are limited due to the flexibility of Luau code (e.g. `a * 1` may not be equivalent to `a` if `*` is overloaded through metatables), even in absence of type information Luau compiler can perform some optimizations such as “deep” constant folding across functions and local variables, perform upvalue optimizations for upvalues that aren’t mutated, do analysis of builtin function usage, optimize the instruction sequences for multiple variable assignments, and some peephole optimizations on the resulting bytecode. The compiler can also be instructed to use more aggressive optimizations by enabling optimization level 2 (`-O2` in CLI tools), some of which are documented further on this page.
Most bytecode optimizations are performed on individual statements or functions, however the compiler also does a limited amount of interprocedural optimizations; notably, calls to local functions can be optimized with the knowledge of the argument count or number of return values involved. Interprocedural optimizations are limited to a single module due to the compilation model.
Luau compiler is also able to use type information to do further optimizations. Because we control the entire stack (unlike e.g. TypeScript where the type information is discarded completely before reaching the VM), we have more flexibility there and can make some tradeoffs during codegen even if the type system isn’t completely sound. For example, it might be reasonable to assume that in presence of known types, we can infer absence of side effects for arithmetic operations and builtins \- if the runtime types mismatch due to intentional violation of the type safety through global injection, the code will still be safely sandboxed. Type information is currently limited to small peephole optimizations, but it has a potential to unlock optimizations such as common subexpression elimination and allocation hoisting in the future, without having to rely on a JIT. These future optimizations opportunities are speculative pending further research.
## Epsilon\-overhead debugger[Permalink](#epsilon-overhead-debugger "Permalink")
It’s important for Luau to have stable and predictable performance. Something that comes up in Lua\-based environments often is the use of line hooks to implement debugging (both for breakpoints and for stepping). This is problematic because the support for hooks is typically not free in general, but importantly once the hook is enabled, calling the hook has a considerable overhead, and the hook itself may be very costly to evaluate since it will need to associate the script:line pair with the breakpoint information.
Luau does not support hooks at all, and relies on first\-class support for breakpoints (using bytecode patching) and single\-stepping (using a custom interpreter loop) to implement debugging. As a result, the presence of breakpoints doesn’t slow the script execution down \- the only noticeable discrepancy between running code under a debugger and without a debugger should be in cases where breakpoints are evaluated and skipped based on breakpoint conditions, or when stepping over long\-running fragments of code.
## Inline caching for table and global access[Permalink](#inline-caching-for-table-and-global-access "Permalink")
Table access for field lookup is optimized in Luau using a mechanism that blends inline caching (classically used in Java/JavaScript VMs) and HREFs (implemented in LuaJIT). Compiler can predict the hash slot used by field lookup, and the VM can correct this prediction dynamically.
As a result, field access can be very fast in Luau, provided that:
* The field name is known at compile time. To make sure this is the case, `table.field` notation is recommended, although the compiler will also optimize `table["field"]` when the expression is known to be a constant string.
* The field access doesn’t use metatables. The fastest way to work with tables in Luau is to store fields directly inside the table, and store methods in the metatable (see below); access to “static” fields in classic OOP designs is best done through `Class.StaticField` instead of `object.StaticField`.
* The object structure is usually uniform. While it’s possible to use the same function to access tables of different shape \- e.g. `function getX(obj) return obj.x end` can be used on any table that has a field `"x"` \- it’s best to not vary the keys used in the tables too much, as it defeats this optimization.
The same optimization is applied to the custom globals declared in the script, although it’s best to avoid these altogether by using locals instead. Still, this means that the difference between `function` and `local function` is less pronounced in Luau.
## Importing global access chains[Permalink](#importing-global-access-chains "Permalink")
While global access for library functions can be optimized in a similar way, this optimization breaks down when the global table is using sandboxing through metatables, and even when globals aren’t sandboxed, `math.max` still requires two table accesses.
It’s always possible to “localize” the global accesses by using `local max = math.max`, but this is cumbersome \- in practice it’s easy to forget to apply this optimization. To avoid relying on programmers remembering to do this, Luau implements a special optimization called “imports”, where most global chains such as `math.max` are resolved when the script is loaded instead of when the script is executed.
This optimization relies on being able to predict the shape of the environment table for a given function; this is possible due to global sandboxing, however this optimization is invalid in some cases:
* `loadstring` can load additional code that runs in context of the caller’s environment
* `getfenv`/`setfenv` can directly modify the environment of any function
The use of any of these functions performs a dynamic deoptimization, marking the affected environment as “impure”. The optimizations are only in effect on functions with “pure” environments \- because of this, the use of `loadstring`/`getfenv`/`setfenv` is not recommended. Note that `getfenv` deoptimizes the environment even if it’s only used to read values from the environment.
> Note: Luau still supports these functions as part of our backwards compatibility promise, although we’d love to switch to Lua 5\.2’s `_ENV` as that mechanism is cleaner and doesn’t require costly dynamic deoptimization.
## Fast method calls[Permalink](#fast-method-calls "Permalink")
Luau specializes method calls to improve their performance through a combination of compiler, VM and binding optimizations. Compiler emits a specialized instruction sequence when methods are called through `obj:Method` syntax (while this isn’t idiomatic anyway, you should avoid `obj.Method(obj)`). When the object in question is a Lua table, VM performs some voodoo magic based on inline caching to try to quickly discover the implementation of this method through the metatable.
For this to be effective, it’s crucial that `__index` in a metatable points to a table directly. For performance reasons it’s strongly recommended to avoid `__index` functions as well as deep `__index` chains; an ideal object in Luau is a table with a metatable that points to itself through `__index`.
When the object in question is a reflected userdata, a special mechanism called “namecall” is used to minimize the interop cost. In classical Lua binding model, `obj:Method` is called in two steps, retrieving the function object (`obj.Method`) and calling it; both steps are often implemented in C\+\+, and the method retrieval needs to use a method object cache \- all of this makes method calls slow.
Luau can directly call the method by name using the “namecall” extension, and an optimized reflection layer can retrieve the correct method quickly through more voodoo magic based on string interning and custom Luau features that aren’t exposed through Luau scripts.
As a result of both optimizations, common Lua tricks of caching the method in a local variable aren’t very productive in Luau and aren’t recommended either.
## Specialized builtin function calls[Permalink](#specialized-builtin-function-calls "Permalink")
Due to global sandboxing and the ability to dynamically deoptimize code running in impure environments, in pure environments we go beyond optimizing the interpreter and optimize many built\-in functions through a “fastcall” mechanism.
For this mechanism to work, function call must be “obvious” to the compiler \- it needs to call a builtin function directly, e.g. `math.max(x, 1)`, although it also works if the function is “localized” (`local max = math.max`); this mechanism doesn’t work for indirect function calls unless they were inlined during compilation, and doesn’t work for method calls (so calling `string.byte` is more efficient than `s:byte`).
The mechanism works by directly invoking a highly specialized and optimized implementation of a builtin function from the interpreter core loop without setting up a stack frame and omitting other work; additionally, some fastcall specializations are partial in that they don’t support all types of arguments, for example all `math` library builtins are only specialized for numeric arguments, so calling `math.abs` with a string argument will fall back to the slower implementation that will do string\-\>number coercion.
As a result, builtin calls are very fast in Luau \- they are still slightly slower than core instructions such as arithmetic operations, but only slightly so. The set of fastcall builtins is slowly expanding over time and as of this writing contains `assert`, `type`, `typeof`, `rawget`/`rawset`/`rawequal`, `getmetatable`/`setmetatable`, `tonumber`/`tostring`, all functions from `math` (except `noise` and `random`/`randomseed`) and `bit32`, and some functions from `string` and `table` library.
Some builtin functions have partial specializations that reduce the cost of the common case further. Notably:
* `assert` is specialized for cases when the assertion return value is not used and the condition is truthy; this helps reduce the runtime cost of assertions to the extent possible
* `bit32.extract` is optimized further when field and width selectors are constant
* `select` is optimized when the second argument is `...`; in particular, `select(x, ...)` is O(1\) when using the builtin dispatch mechanism even though it’s normally O(N) in variadic argument count.
Some functions from `math` library like `math.floor` can additionally take advantage of advanced SIMD instruction sets like SSE4\.1 when available.
In addition to runtime optimizations for builtin calls, many builtin calls, as well as constants like `math.pi`/`math.huge`, can also be constant\-folded by the bytecode compiler when using aggressive optimizations (level 2\); this currently applies to most builtin calls with constant arguments and a single return value. For builtin calls that can not be constant folded, compiler assumes knowledge of argument/return count (level 2\) to produce more efficient bytecode instructions.
## Optimized table iteration[Permalink](#optimized-table-iteration "Permalink")
Luau implements a fully generic iteration protocol; however, for iteration through tables in addition to generalized iteration (`for .. in t`) it recognizes three common idioms (`for .. in ipairs(t)`, `for .. in pairs(t)` and `for .. in next, t`) and emits specialized bytecode that is carefully optimized using custom internal iterators.
As a result, iteration through tables typically doesn’t result in function calls for every iteration; the performance of iteration using generalized iteration, `pairs` and `ipairs` is comparable, so generalized iteration (without the use of `pairs`/`ipairs`) is recommended unless the code needs to be compatible with vanilla Lua or the specific semantics of `ipairs` (which stops at the first `nil` element) is required. Additionally, using generalized iteration avoids calling `pairs` when the loop starts which can be noticeable when the table is very short.
Iterating through array\-like tables using `for i=1,#t` tends to be slightly slower because of extra cost incurred when reading elements from the table.
## Optimized table length[Permalink](#optimized-table-length "Permalink")
Luau tables use a hybrid array/hash storage, like in Lua; in some sense “arrays” don’t truly exist and are an internal optimization, but some operations, notably `#t` and functions that depend on it, like `table.insert`, are defined by the Luau/Lua language to allow internal optimizations. Luau takes advantage of that fact.
Unlike Lua, Luau guarantees that the element at index `#t` is stored in the array part of the table. This can accelerate various table operations that use indices limited by `#t`, and this makes `#t` worst\-case complexity O(logN), unlike Lua where the worst case complexity is O(N). This also accelerates computation of this value for small tables like `{ [1] = 1 }` since we never need to look at the hash part.
The “default” implementation of `#t` in both Lua and Luau is a binary search. Luau uses a special branch\-free (depending on the compiler…) implementation of the binary search which results in 50\+% faster computation of table length when it needs to be computed from scratch.
Additionally, Luau can cache the length of the table and adjust it following operations like `table.insert`/`table.remove`; this means that in practice, `#t` is almost always a constant time operation.
## Creating and modifying tables[Permalink](#creating-and-modifying-tables "Permalink")
Luau implements several optimizations for table creation. When creating object\-like tables, it’s recommended to use table literals (`{ ... }`) and to specify all table fields in the literal in one go instead of assigning fields later; this triggers an optimization inspired by LuaJIT’s “table templates” and results in higher performance when creating objects. When creating array\-like tables, if the maximum size of the table is known up front, it’s recommended to use `table.create` function which can create an empty table with preallocated storage, and optionally fill it with a given value.
When the exact table shape isn’t known, Luau compiler can still predict the table capacity required in case the table is initialized with an empty literal (`{}`) and filled with fields subsequently. For example, the following code creates a correctly sized table implicitly:
```
local v = {}
v.x = 1
v.y = 2
v.z = 3
return v
```
When appending elements to tables, it’s recommended to use `table.insert` (which is the fastest method to append an element to a table if the table size is not known). In cases when a table is filled sequentially, however, it can be more efficient to use a known index for insertion \- together with preallocating tables using `table.create` this can result in much faster code, for example this is the fastest way to build a table of squares:
```
local t = table.create(N)
for i=1,N do
t[i] = i * i
end
```
## Native vector math[Permalink](#native-vector-math "Permalink")
Luau uses tagged value storage \- each value contains a type tag and the data that represents the value of a given type. Because of the need to store 64\-bit double precision numbers *and* 64\-bit pointers, we don’t use NaN tagging and have to pay the cost of 16 bytes per value.
We take advantage of this to provide a native value type that can store a 32\-bit floating point vector with 3 components. This type is fundamental to game computations and as such it’s important to optimize the storage and the operations with that type \- our VM implements first class support for all math operations and component manipulation, which essentially means we have native 3\-wide SIMD support. For code that uses many vector values this results in significantly smaller GC pressure and significantly faster execution, and gives programmers a mechanism to hand\-vectorize numeric code if need be.
## Optimized upvalue storage[Permalink](#optimized-upvalue-storage "Permalink")
Lua implements upvalues as garbage collected objects that can point directly at the thread’s stack or, when the value leaves the stack frame (and is “closed”), store the value inside the object. This representation is necessary when upvalues are mutated, but inefficient when they aren’t \- and 90% or more of upvalues aren’t mutated in typical Lua code. Luau takes advantage of this by reworking upvalue storage to prioritize immutable upvalues \- capturing upvalues that don’t change doesn’t require extra allocations or upvalue closing, resulting in faster closure allocation, faster execution, faster garbage collection and faster upvalue access due to better memory locality.
Note that “immutable” in this case only refers to the variable itself \- if the variable isn’t assigned to it can be captured by value, even if it’s a table that has its contents change.
When upvalues are mutable, they do require an extra allocated object; we carefully optimize the memory consumption and access cost for mutable upvalues to reduce the associated overhead.
## Closure caching[Permalink](#closure-caching "Permalink")
With optimized upvalue storage, creating new closures (function objects) is more efficient but still requires allocating a new object every time. This can be problematic for cases when functions are passed to algorithms like `table.sort` or functions like `pcall`, as it results in excessive allocation traffic which then leads to more work for garbage collector.
To make closure creation cheaper, Luau compiler implements closure caching \- when multiple executions of the same function expression are guaranteed to result in the function object that is semantically identical, the compiler may cache the closure and always return the same object. This changes the function identity which may affect code that uses function objects as table keys, but preserves the calling semantics \- compiler will only do this if calling the original (cached) function behaves the same way as a newly created function would. The heuristics used for this optimization are subject to change; currently, the compiler will cache closures that have no upvalues, or all upvalues are immutable (see previous section) and are declared at the module scope, as the module scope is (almost always) evaluated only once.
## Fast memory allocator[Permalink](#fast-memory-allocator "Permalink")
Similarly to LuaJIT, but unlike vanilla Lua, Luau implements a custom allocator that is highly specialized and tuned to the common allocation workloads we see. The allocator design is inspired by classic pool allocators as well as the excellent `mimalloc`, but through careful domain\-specific tuning it beats all general purpose allocators we’ve tested, including `rpmalloc`, `mimalloc`, `jemalloc`, `ptmalloc` and `tcmalloc`.
This doesn’t mean that memory allocation in Luau is free \- it’s carefully optimized, but it still carries a cost, and a high rate of allocations requires more work from the garbage collector. The garbage collector is incremental, so short of some edge cases this rarely results in visible GC pauses, but can impact the throughput since scripts will interrupt to perform “GC assists” (helping clean up the garbage). Thus for high performance Luau code it’s recommended to avoid allocating memory in tight loops, by avoiding temporary table and userdata creation.
In addition to a fast allocator, all frequently used structures in Luau have been optimized for memory consumption, especially on 64\-bit platforms, compared to Lua 5\.1 baseline. This helps to reduce heap memory footprint and improve performance in some cases by reducing the memory bandwidth impact of garbage collection.
## Optimized libraries[Permalink](#optimized-libraries "Permalink")
While the best performing code in Luau spends most of the time in the interpreter, performance of the standard library functions is critical to some applications. In addition to specializing many small and simple functions using the builtin call mechanism, we spend extra care on optimizing all library functions and providing additional functions beyond the Lua standard library that help achieve good performance with idiomatic code.
Functions from the `table` library like `insert`, `remove` and `move` have been tuned for performance on array\-like tables, achieving 3x and more performance compared to un\-tuned versions, and Luau provides additional functions like `table.create` and `table.find` to achieve further speedup when applicable. Our implementation of `table.sort` is using `introsort` algorithm which results in guaranteed worst case `NlogN` complexity regardless of the input, and, together with the array\-like specializations, helps achieve \~4x speedup on average.
For `string` library, we use a carefully tuned dynamic string buffer implementation; it is optimized for smaller strings to reduce garbage created during string manipulation, and for larger strings it allows to produce a large string without extra copies, especially in cases where the resulting size is known ahead of time. Additionally, functions like `format` have been tuned to avoid the overhead of `sprintf` where possible, resulting in further speedups.
## Improved garbage collector pacing[Permalink](#improved-garbage-collector-pacing "Permalink")
Luau uses an incremental garbage collector which does a little bit of work every so often, and at no point does it stop the world to traverse the entire heap. The runtime will make sure that the collector runs interspersed with the program execution as the program allocates additional memory, which is known as “garbage collection assists”, and can also run in response to explicit garbage collection invocation via `lua_gc`. In interactive environments such as video game engines it’s possible, and even desirable, to request garbage collection every frame to make sure assists are minimized, since that allows scheduling the garbage collection to run concurrently with other engine processing that doesn’t involve script execution.
Inspired by excellent work by Austin Clements on Go’s garbage collector pacer, we’ve implemented a pacing algorithm that uses a proportional–integral–derivative controller to estimate internal garbage collector tunables to reach a target heap size, defined as a percentage of the live heap data (which is more intuitive and actionable than Lua 5\.x “GC pause” setting). Luau runtime also estimates the allocation rate making it easy (given uniform allocation rates) to adjust the per\-frame garbage collection requests to do most of the required GC work outside of script execution.
## Reduced garbage collector pauses[Permalink](#reduced-garbage-collector-pauses "Permalink")
While Luau uses an incremental garbage collector, once per each collector cycle it runs a so\-called “atomic” step. While all other GC steps can do very little work by only looking at a few objects at a given time, which means that the collector can have arbitrarily short pauses, the “atomic” step needs to traverse some amount of data that, in some cases, may scale with the application heap. Since atomic step is indivisible, it can result in occasional pauses on the order of tens of milliseconds, which is problematic for interactive applications. We’ve implemented a series of optimizations to help reduce the atomic step.
Normally objects that have been modified after the GC marked them in an incremental mark phase need to be rescanned during atomic phase, so frequent modifications of existing tables may result in a slow atomic step. To address this, we run a “remark” step where we traverse objects that have been modified after being marked once more (incrementally); additionally, the write barrier that triggers for object modifications changes the transition logic during remark phase to reduce the probability that the object will need to be rescanned.
Another source of scalability challenges is coroutines. Writes to coroutine stacks don’t use a write barrier, since that’s prohibitively expensive as they are too frequent. This means that coroutine stacks need to be traversed during atomic step, so applications with many coroutines suffer large atomic pauses. To address this, we implement incremental marking of coroutines: marking a coroutine makes it “inactive” and resuming a coroutine (or pushing extra objects on the coroutine stack via C API) makes it “active”. Atomic step only needs to traverse active coroutines again, which reduces the cost of atomic step by effectively making coroutine collection incremental as well.
While large tables can be a problem for incremental GC in general since currently marking a single object is indivisible, large weak tables are a unique challenge because they also need to be processed during atomic phase, and the main use case for weak tables \- object caches \- may result in tables with large capacity but few live objects in long\-running applications that exhibit bursts of activity. To address this, weak tables in Luau can be marked as “shrinkable” by including `s` as part of `__mode` string, which results in weak tables being resized to the optimal capacity during GC. This option may result in missing keys during table iteration if the table is resized while iteration is in progress and as such is only recommended for use in specific circumstances.
## Optimized garbage collector sweeping[Permalink](#optimized-garbage-collector-sweeping "Permalink")
The incremental garbage collector in Luau runs three phases for each cycle: mark, atomic and sweep. Mark incrementally traverses all live objects, atomic finishes various operations that need to happen without mutator intervention (see previous section), and sweep traverses all objects in the heap, reclaiming memory used by dead objects and performing minor fixup for live objects. While objects allocated during the mark phase are traversed in the same cycle and thus may get reclaimed, objects allocated during the sweep phase are considered live. Because of this, the faster the sweep phase completes, the less garbage will accumulate; and, of course, the less time sweeping takes the less overhead there is from this phase of garbage collection on the process.
Since sweeping traverses the whole heap, we maximize the efficiency of this traversal by allocating garbage\-collected objects of the same size in 16 KB pages, and traversing each page at a time, which is otherwise known as a paged sweeper. This ensures good locality of reference as consecutively swept objects are contiguous in memory, and allows us to spend no memory for each object on sweep\-related data or allocation metadata, since paged sweeper doesn’t need to be able to free objects without knowing which page they are in. Compared to linked list based sweeping that Lua/LuaJIT implement, paged sweeper is 2\-3x faster, and saves 16 bytes per object on 64\-bit platforms.
## Function inlining and loop unrolling[Permalink](#function-inlining-and-loop-unrolling "Permalink")
By default, the bytecode compiler performs a series of optimizations that result in faster execution of the code, but they preserve both execution semantics and debuggability. For example, a function call is compiled as a function call, which may be observable via `debug.traceback`; a loop is compiled as a loop, which may be observable via `lua_getlocal`. To help improve performance in cases where these restrictions can be relaxed, the bytecode compiler implements additional optimizations when optimization level 2 is enabled (which requires using `-O2` switch when using Luau CLI), namely function inlining and loop unrolling.
Only loops with loop bounds known at compile time, such as `for i=1,4 do`, can be unrolled. The loop body must be simple enough for the optimization to be profitable; compiler uses heuristics to estimate the performance benefit and automatically decide if unrolling should be performed.
Only local functions (defined either as `local function foo` or `local foo = function`) can be inlined. The function body must be simple enough for the optimization to be profitable; compiler uses heuristics to estimate the performance benefit and automatically decide if each call to the function should be inlined instead. Additionally recursive invocations of a function can’t be inlined at this time, and inlining is completely disabled for modules that use `getfenv`/`setfenv` functions.
In both cases, in addition to removing the overhead associated with function calls or loop iteration, these optimizations can additionally benefit by enabling additional optimizations, such as constant folding of expressions dependent on loop iteration variable or constant function arguments, or using more efficient instructions for certain expressions when the inputs to these instructions are constants.
| 4 |
https://luau.org/sandbox
|
en-us
|
# Sandboxing
#### On this page
* [Library](#library)
* [Environment](#environment)
* [\_\_gc](#__gc)
* [Interrupts](#interrupts)
Luau is safe to embed. Broadly speaking, this means that even in the face of untrusted (and in Roblox case, actively malicious) code, the language and the standard library don’t allow unsafe access to the underlying system, and don’t have known bugs that allow escaping out of the sandbox (e.g. to gain native code execution through ROP gadgets et al). Additionally, the VM provides extra features to implement isolation of privileged code from unprivileged code and protect one from the other; this is important if the embedding environment decides to expose some APIs that may not be safe to call from untrusted code, for example because they do provide controlled access to the underlying system or risk PII exposure through fingerprinting etc.
This safety is achieved through a combination of removing features from the standard library that are unsafe, adding features to the VM that make it possible to implement sandboxing and isolation, and making sure the implementation is safe from memory safety issues using fuzzing.
Of course, since the entire stack is implemented in C\+\+, the sandboxing isn’t formally proven \- in theory, compiler or the standard library can have exploitable vulnerabilities. In practice these are very rare and usually found and fixed quickly. While implementing the stack in a safer language such as Rust would make it easier to provide these guarantees, to our knowledge (based on prior art) this would make it difficult to reach the level of performance required.
## Library[Permalink](#library "Permalink")
Parts of the Lua 5\.x standard library are unsafe. Some of the functions provide access to the host operating system, including process execution and file reads. Some functions lack sufficient memory safety checks. Some functions are safe if all code is untrusted, but can break the isolation barrier between trusted and untrusted code.
The following libraries and global functions have been removed as a result:
* `io.` library has been removed entirely, as it gives access to files and allows running processes
* `package.` library has been removed entirely, as it gives access to files and allows loading native modules
* `os.` library has been cleaned up from file and environment access functions (`execute`, `exit`, etc.). The only supported functions in the library are `clock`, `date`, `difftime` and `time`.
* `debug.` library has been removed to a large extent, as it has functions that aren’t memory safe and other functions break isolation; the only supported functions are `traceback` and `info` (which is similar to `debug.getinfo` but has a slightly different interface).
* `dofile` and `loadfile` allowed access to file system and have been removed.
To achieve memory safety, access to function bytecode has been removed. Bytecode is hard to validate and using untrusted bytecode may lead to exploits. Thus, `loadstring` doesn’t work with bytecode inputs, and `string.dump`/`load` have been removed as they aren’t necessary anymore. When embedding Luau, bytecode should be encrypted/signed to prevent MITM attacks as well, as the VM assumes that the bytecode was generated by the Luau compiler (which never produces invalid/unsafe bytecode).
Finally, to make isolation possible within the same VM, the following global functions have reduced functionality:
* `collectgarbage` only works with `"count"` argument, as modifying the state of GC can interfere with the expectations of other code running in the process. As such, `collectgarbage()` became an inferior version of `gcinfo()` and is deprecated.
* `newproxy` only works with `true`/`false`/`nil` arguments.
* `module` allowed overriding global packages and was removed as a result.
> Note: `getfenv`/`setfenv` result in additional isolation challenges, as they allow injecting globals into scripts on the call stack. Ideally, these should be disabled as well, but unfortunately Roblox community relies on these for various reasons. This can be mitigated by limiting interaction between trusted and untrusted code, and/or using separate VMs.
## Environment[Permalink](#environment "Permalink")
The modification to the library functions are sufficient to make embedding safe, but aren’t sufficient to provide isolation within the same VM. It should be noted that to achieve guaranteed isolation, it’s advisable to load trusted and untrusted code into separate VMs; however, even within the same VM Luau provides additional safety features to make isolation cheaper.
When initializing the default globals table, the tables are protected from modification:
* All libraries (`string`, `math`, etc.) are marked as readonly
* The string metatable is marked as readonly
* The global table itself is marked as readonly
This is using the VM feature that is not accessible from scripts, that prevents all writes to the table, including assignments, `rawset` and `setmetatable`. This makes sure that globals can’t be monkey\-patched in place, and can only be substituted through `setfenv`.
By itself this would mean that code that runs in Luau can’t use globals at all, since assigning globals would fail. While this is feasible, in Roblox we solve this by creating a new global table for each script, that uses `__index` to point to the builtin global table. This safely sandboxes the builtin globals while still allowing writing globals from each script. This also means that short of exposing special shared globals from the host, all scripts are isolated from each other.
## `__gc`[Permalink](#__gc "Permalink")
Lua 5\.1 exposes a `__gc` metamethod for userdata, which can be used on proxies (`newproxy`) to hook into garbage collector. Later versions of Lua extend this mechanism to work on tables.
This mechanism is bad for performance, memory safety and isolation:
* In Lua 5\.1, `__gc` support requires traversing userdata lists redundantly during garbage collection to filter out finalizable objects
* In later versions of Lua, userdata that implement `__gc` are split into separate lists; however, finalization prolongs the lifetime of the finalized objects which results in less prompt memory reclamation, and two\-step destruction results in extra cache misses for userdata
* `__gc` runs during garbage collection in context of an arbitrary thread which makes the thread identity mechanism used in Roblox to support trusted Luau code invalid
* Objects can be removed from weak tables *after* being finalized, which means that accessing these objects can result in memory safety bugs, unless all exposed userdata methods guard against use\-after\-gc.
* If `__gc` method ever leaks to scripts, they can call it directly on an object and use any method exposed by that object after that. This means that `__gc` and all other exposed methods must support memory safety when called on a destroyed object.
Because of these issues, Luau does not support `__gc`. Instead it uses tag\-based destructors that can perform additional memory cleanup during userdata destruction; crucially, these are only available to the host (so they can never be invoked manually), and they run right before freeing the userdata memory block which is both optimal for performance, and guaranteed to be memory safe.
For monitoring garbage collector behavior the recommendation is to use weak tables instead.
## Interrupts[Permalink](#interrupts "Permalink")
In addition to preventing API access, it can be important for isolation to limit the memory and CPU usage of code that runs inside the VM.
By default, no memory limits are imposed on the running code, so it’s possible to exhaust the address space of the host; this is easy to configure from the host for Luau allocations, but of course with a rich API surface exposed by the host it’s hard to eliminate this as a possibility. Memory exhaustion doesn’t result in memory safety issues or any particular risk to the system that’s running the host process, other than the host process getting terminated by the OS.
Limiting CPU usage can be equally challenging with a rich API. However, Luau does provide a VM\-level feature to try to contain runaway scripts which makes it possible to terminate any script externally. This works through a global interrupt mechanism, where the host can setup an interrupt handler at any point, and any Luau code is guaranteed to call this handler “eventually” (in practice this can happen at any function call or at any loop iteration). This still leaves the possibility of a very long running script open if the script manages to find a way to call a single C function that takes a lot of time, but short of that the interruption is very prompt.
Roblox sets up the interrupt handler using a watchdog that:
* Limits the runtime of any script in Studio to 10 seconds (configurable through Studio settings)
* Upon client shutdown, interrupts execution of every running script 1 second after shutdown
| 5 |
https://luau.org/compatibility
|
en-us
|
# Compatibility
#### On this page
* [Implementation limits](#implementation-limits)
* [Lua 5\.1](#lua-51)
* [Lua 5\.2](#lua-52)
* [Lua 5\.3](#lua-53)
* [Lua 5\.4](#lua-54)
* [Differences from Lua](#differences-from-lua)
Luau is based on Lua 5\.1, and as such incorporates all features of 5\.1, except for ones that had to be taken out due to sandboxing limitations. Because of backwards compatibility constraints, we don’t remove features deprecated by later versions (e.g. we still support `getfenv`/`setfenv`). Later Lua versions introduce new features into the language and new libraries/functions.
Our overall goal is to incorporate features from the later versions of Lua when it makes sense for us to do so \- the motivations behind some newer features are unclear or don’t apply to the domain Luau is used in, and many features carry costs that don’t always make sense to pay. The rest of this document describes the status of all features of Lua 5\.2 and beyond, with the following classification:
* ✔️ \- the feature is available in Luau
* ❌ \- the feature is not available in Luau because we don’t believe it makes sense to include it
* 😞 \- the feature is not available in Luau because of compatibility/sandboxing concerns
* 🔜 \- the feature is not available in Luau yet but we’d like to include it and are possibly working on it
* 🤷♀️ \- the feature is not available in Luau yet; we don’t have strong opinions on it so it might make it at some point
Please note that all of these decisions are not final, they are just our current stance. In some cases evolution of our VM may make a feature that was previously impractical to support due to performance complications feasible. In some cases a feature that didn’t have a strong use case gains one, so we can implement it.
## Implementation limits[Permalink](#implementation-limits "Permalink")
Luau has certain limitations around the number of local variables, registers, upvalues, constants and instructions. These limits are often different from the limits imposed by various versions of Lua, and are documented here without promising that future versions will adhere to these. Note that writing code that is close to any of these limits is dangerous because this code may become invalid as our codegen evolves.
* Local variables: 200 per function (same as all versions of Lua, this includes function arguments)
* Upvalues: 200 per function (up from 60 in Lua 5\.1\)
* Registers: 255 per function (same as all versions of Lua, this includes local variables and function arguments)
* Constants: 2^23 per function (up from 2^18 in Lua 5\.1\)
* Instructions: 2^23 per function (up from 2^17 in Lua 5\.1, although in both cases the limit only applies to control flow)
* Nested functions: 2^15 per function (down from 2^18 in Lua 5\.1\)
* Stack depth: 20000 Lua calls per Lua thread, 200 C calls per C thread (e.g. `coroutine.resume`/`pcall` nesting is limited to 200\)
Note that Lua 5\.3 has a larger upvalue limit (255\) and a larger constant limit (2^26\); existing Luau limits are likely sufficient for reasonable use cases.
## Lua 5\.1[Permalink](#lua-51 "Permalink")
Since several features were removed from Lua 5\.1 for sandboxing reasons, this table lists them for completeness.
| feature | notes |
| --- | --- |
| `io`, `os`, `package` and `debug` library | note that some functions in `os`/`debug` are still present |
| `loadfile`, `dofile` | removed for sandboxing, no direct file access |
| `loadstring` bytecode and `string.dump` | exposing bytecode is dangerous for sandboxing reasons |
| `newproxy` can only be called with nil or boolean | extra flexibility removed for sandboxing |
Sandboxing challenges are [covered in the dedicated section](sandbox).
## Lua 5\.2[Permalink](#lua-52 "Permalink")
| feature | status | notes |
| --- | --- | --- |
| yieldable pcall/xpcall | ✔️ | |
| yieldable xpcall error handler | ❌ | no strong use cases, VM complexity and performance implications |
| yieldable metamethods | ❌ | significant performance implications |
| ephemeron tables | ❌ | this complicates and slows down the garbage collector esp. for large weak tables |
| emergency garbage collector | 🤷 | Luau runs in environments where handling memory exhaustion in emergency situations is not tenable |
| goto statement | ❌ | this complicates the compiler, makes control flow unstructured and doesn’t address a significant need |
| finalizers for tables | ❌ | no `__gc` support due to sandboxing and performance/complexity |
| no more fenv for threads or functions | 😞 | we love this, but it breaks compatibility |
| tables honor the `__len` metamethod | ✔️ | |
| hex and `\z` escapes in strings | ✔️ | |
| support for hexadecimal floats | 🤷♀️ | no strong use cases |
| order metamethods (`__lt`/`__le`) are called for unrelated metatables | ❌ | no strong use cases and more complicated semantics, compatibility and performance implications |
| empty statement | 🤷♀️ | less useful in Lua than in JS/C\#/C/C\+\+ |
| `break` statement may appear in the middle of a block | 🤷♀️ | we’d like to do it consistently for `break`/`return`/`continue` but there be dragons |
| arguments for function called through `xpcall` | ✔️ | |
| optional base in `math.log` | ✔️ | |
| optional separator in `string.rep` | 🤷♀️ | no strong use cases |
| new metamethods `__pairs` and `__ipairs` | ❌ | superseded by `__iter` |
| frontier patterns | ✔️ | |
| `%g` in patterns | ✔️ | |
| `\0` in patterns | ✔️ | |
| `bit32` library | ✔️ | |
| `string.gsub` is stricter about using `%` on special characters only | ✔️ | |
| light C functions | 😞 | this changes semantics of fenv on C functions and has complex implications wrt runtime performance |
| NaN keys are supported for tables with `__newindex` | ✔️ | |
Two things that are important to call out here are various new metamethods for tables and yielding in metamethods. In both cases, there are performance implications to supporting this \- our implementation is *very* highly tuned for performance, so any changes that affect the core fundamentals of how Lua works have a price. To support yielding in metamethods we’d need to make the core of the VM more involved, since almost every single “interesting” opcode would need to learn how to be resumable \- which also complicates future JIT/AOT story. Metamethods in general are important for extensibility, but very challenging to deal with in implementation, so we err on the side of not supporting any new metamethods unless a strong need arises.
For `__pairs`/`__ipairs`, we felt that extending library functions to enable custom containers wasn’t the right choice. Instead we revisited iteration design to allow for self\-iterating objects via `__iter` metamethod, which results in a cleaner iteration design that also makes it easier to iterate over tables. As such, we have no plans to support `__pairs`/`__ipairs` as all use cases for it can now be solved by `__iter`.
Ephemeron tables may be implemented at some point since they do have valid uses and they make weak tables semantically cleaner, however the cleanup mechanism for these is expensive and complicated, and as such this can only be considered after the pending GC rework is complete.
## Lua 5\.3[Permalink](#lua-53 "Permalink")
| feature | status | notes |
| --- | --- | --- |
| `\u` escapes in strings | ✔️ | |
| integers (64\-bit by default) | ❌ | backwards compatibility and performance implications |
| bitwise operators | ❌ | `bit32` library covers this in absence of 64\-bit integers |
| basic utf\-8 support | ✔️ | we include `utf8` library and other UTF8 features |
| functions for packing and unpacking values (string.pack/unpack/packsize) | ✔️ | |
| floor division | ✔️ | |
| `ipairs` and the `table` library respect metamethods | ❌ | no strong use cases, performance implications |
| new function `table.move` | ✔️ | |
| `collectgarbage("count")` now returns only one result | ✔️ | |
| `coroutine.isyieldable` | ✔️ | |
| stricter error checking for `table.insert`/`table.remove` | 😞 | we love this, but it breaks compatibility |
| `__eq` metamethod is called for unrelated metatables | ❌ | backwards compatibility and typechecking implications |
It’s important to highlight integer support and bitwise operators. For Luau, it’s rare that a full 64\-bit integer type is necessary \- double\-precision types support integers up to 2^53 (in Lua which is used in embedded space, integers may be more appealing in environments without a native 64\-bit FPU). However, there’s a *lot* of value in having a single number type, both from performance perspective and for consistency. Notably, Lua doesn’t handle integer overflow properly, so using integers also carries compatibility implications.
If integers are taken out of the equation, bitwise operators make less sense, as integers aren’t a first class feature; additionally, `bit32` library is more fully featured (includes commonly used operations such as rotates and arithmetic shift; bit extraction/replacement is also more readable). Adding operators along with metamethods for all of them increases complexity, which means this feature isn’t worth it on the balance. Common arguments for this include a more familiar syntax, which, while true, gets more nuanced as `^` isn’t available as a xor operator, and arithmetic right shift isn’t expressible without yet another operator, and performance, which in Luau is substantially better than in Lua because `bit32` library uses VM builtins instead of expensive function calls.
## Lua 5\.4[Permalink](#lua-54 "Permalink")
| feature | status | notes |
| --- | --- | --- |
| new generational mode for garbage collection | 🔜 | we’re working on gc optimizations and generational mode is on our radar |
| to\-be\-closed variables | ❌ | the syntax is inconsistent with how we’d like to do attributes long\-term; no strong use cases in our domain |
| const variables | ❌ | while there’s some demand for const variables, we’d never adopt this syntax |
| new implementation for math.random | ✔️ | our RNG is based on PCG, unlike Lua 5\.4 which uses Xoroshiro |
| optional `init` argument to `string.gmatch` | 🤷♀️ | no strong use cases |
| new functions `lua_resetthread` and `coroutine.close` | ✔️ | |
| coercions string\-to\-number moved to the string library | 😞 | we love this, but it breaks compatibility |
| new format `%p` in `string.format` | 🤷♀️ | no strong use cases |
| `utf8` library accepts codepoints up to 2^31 | 🤷♀️ | no strong use cases |
| The use of the `__lt` metamethod to emulate `__le` has been removed | ❌ | breaks compatibility and complicates comparison overloading story |
| When finalizing objects, Lua will call `__gc` metamethods that are not functions | ❌ | no `__gc` support due to sandboxing and performance/complexity |
| function `print` calls `__tostring` instead of `tostring` to format its arguments | ✔️ | |
| decoding functions in the utf8 library do not accept surrogates | ✔️ | |
Taking syntax aside (which doesn’t feel idiomatic or beautiful), `<close>` isn’t very useful in Luau \- its dominant use case is for code that works with external resources like files or sockets, but we don’t provide such APIs \- and has a very large complexity cost, evidences by a lot of bug fixes since the initial implementation in 5\.4 work versions. `<const>` in Luau doesn’t matter for performance \- our multi\-pass compiler is already able to analyze the usage of the variable to know if it’s modified or not and extract all performance gains from it \- so the only use here is for code readability, where the `<const>` syntax is… suboptimal.
If we do end up introducing const variables, it would be through a `const var = value` syntax, which is backwards compatible through a context\-sensitive keyword similar to `type`. That said, there’s ambiguity wrt whether `const` should simply behave like a read\-only variable, ala JavaScript, or if it should represent a stronger contract, for example by limiting the expressions on the right hand side to ones compiler can evaluate ahead of time, or by freezing table values and thus guaranteeing immutability.
## Differences from Lua[Permalink](#differences-from-lua "Permalink")
We have a few behavior deviations from Lua 5\.x that come from either a different implementation, or our desire to clean up small inconsistencies in the language/libraries:
* Tail calls are not supported to simplify implementation, make debugging/stack traces more predictable and allow deep validation of caller identity for security
* Order of table assignment in table literals follows program order in mixed tables (Lua 5\.x assigns array elements first in some cases)
* Equality comparisons call `__eq` metamethod even when objects are rawequal (which matches other metamethods like `<=` and facilitates NaN checking)
* `function()` expressions may reuse a previously created closure in certain scenarios (when all upvalues captured are the same) for efficiency, which changes object identity but doesn’t change call semantics – this is different from Lua 5\.1 but similar to Lua 5\.2/5\.3
* `os.time` returns UTC timestamp when called with a table for consistency
| 6 |
https://luau.org/typecheck
|
en-us
|
# Type checking
#### On this page
* [Type inference modes](#type-inference-modes)
* [Structural type system](#structural-type-system)
* [Builtin types](#builtin-types)
+ [unknown type](#unknown-type)
+ [never type](#never-type)
+ [any type](#any-type)
* [Function types](#function-types)
* [Table types](#table-types)
+ [Unsealed tables](#unsealed-tables)
+ [Sealed tables](#sealed-tables)
+ [Generic tables](#generic-tables)
* [Table indexers](#table-indexers)
* [Generics](#generics)
* [Generic functions](#generic-functions)
* [Union types](#union-types)
* [Intersection types](#intersection-types)
* [Singleton types (aka literal types)](#singleton-types-aka-literal-types)
* [Variadic types](#variadic-types)
* [Type packs](#type-packs)
* [Adding types for faux object oriented programs](#adding-types-for-faux-object-oriented-programs)
* [Tagged unions](#tagged-unions)
* [Type refinements](#type-refinements)
* [Type casts](#type-casts)
* [Roblox types](#roblox-types)
* [Module interactions](#module-interactions)
+ [Cyclic module dependencies](#cyclic-module-dependencies)
* [Type functions](#type-functions)
+ [Type function environment](#type-function-environment)
* [types library](#types-library)
+ [types library properties](#types-library-properties)
* [types library functions](#types-library-functions)
+ [type instance](#type-instance)
+ [Singleton type instance](#singleton-type-instance)
+ [Generic type instance](#generic-type-instance)
+ [Table type instance](#table-type-instance)
+ [Function type instance](#function-type-instance)
+ [Negation type instance](#negation-type-instance)
+ [Union type instance](#union-type-instance)
+ [Intersection type instance](#intersection-type-instance)
+ [Class type instance](#class-type-instance)
Luau supports a gradual type system through the use of type annotations and type inference.
## Type inference modes[Permalink](#type-inference-modes "Permalink")
There are three modes currently available. They must be annotated on the top few lines among the comments.
* `--!nocheck`,
* `--!nonstrict` (default), and
* `--!strict`
`nocheck` mode will simply not start the type inference engine whatsoever.
As for the other two, they are largely similar but with one important difference: in nonstrict mode, we infer `any` for most of the types if we couldn’t figure it out early enough. This means that given this snippet:
```
local foo = 1
```
We can infer `foo` to be of type `number`, whereas the `foo` in the snippet below is inferred `any`:
```
local foo
foo = 1
```
However, given the second snippet in strict mode, the type checker would be able to infer `number` for `foo`.
## Structural type system[Permalink](#structural-type-system "Permalink")
Luau’s type system is structural by default, which is to say that we inspect the shape of two tables to see if they are similar enough. This was the obvious choice because Lua 5\.1 is inherently structural.
```
type A = {x: number, y: number, z: number?}
type B = {x: number, y: number, z: number}
local a1: A = {x = 1, y = 2} -- ok
local b1: B = {x = 1, y = 2, z = 3} -- ok
local a2: A = b1 -- ok
local b2: B = a1 -- not ok
```
## Builtin types[Permalink](#builtin-types "Permalink")
The Luau VM supports 10 primitive types: `nil`, `string`, `number`, `boolean`, `table`, `function`, `thread`, `userdata`, `vector`, and `buffer`. Of these, `table` and `function` are not represented by name, but have their dedicated syntax as covered in this [syntax document](syntax), `userdata` is represented by [concrete types](#roblox-types), while `vector` is not representable by name at all; other types can be specified by their name.
The type checker also provides the builtin types [`unknown`](#unknown-type), [`never`](#never-type), and [`any`](#any-type).
```
local s = "foo"
local n = 1
local b = true
local t = coroutine.running()
local a: any = 1
print(a.x) -- Type checker believes this to be ok, but crashes at runtime.
```
There’s a special case where we intentionally avoid inferring `nil`. It’s a good thing because it’s never useful for a local variable to always be `nil`, thereby permitting you to assign things to it for Luau to infer that instead.
```
local a
local b = nil
```
### `unknown` type[Permalink](#unknown-type "Permalink")
`unknown` is also said to be the *top* type, that is it’s a union of all types.
```
local a: unknown = "hello world!"
local b: unknown = 5
local c: unknown = function() return 5 end
```
Unlike `any`, `unknown` will not allow itself to be used as a different type!
```
local function unknown(): unknown
return if math.random() > 0.5 then "hello world!" else 5
end
local a: string = unknown() -- not ok
local b: number = unknown() -- not ok
local c: string | number = unknown() -- not ok
```
In order to turn a variable of type `unknown` into a different type, you must apply [type refinements](#type-refinements) on that variable.
```
local x = unknown()
if typeof(x) == "number" then
-- x : number
end
```
### `never` type[Permalink](#never-type "Permalink")
`never` is also said to be the *bottom* type, meaning there doesn’t exist a value that inhabits the type `never`. In fact, it is the *dual* of `unknown`. `never` is useful in many scenarios, and one such use case is when type refinements proves it impossible:
```
local x = unknown()
if typeof(x) == "number" and typeof(x) == "string" then
-- x : never
end
```
### `any` type[Permalink](#any-type "Permalink")
`any` is just like `unknown`, except that it allows itself to be used as an arbitrary type without further checks or annotations. Essentially, it’s an opt\-out from the type system entirely.
```
local x: any = 5
local y: string = x -- no type errors here!
```
## Function types[Permalink](#function-types "Permalink")
Let’s start with something simple.
```
local function f(x) return x end
local a: number = f(1) -- ok
local b: string = f("foo") -- ok
local c: string = f(true) -- not ok
```
In strict mode, the inferred type of this function `f` is `<A>(A) -> A` (take a look at [generics](#generics)), whereas in nonstrict we infer `(any) -> any`. We know this is true because `f` can take anything and then return that. If we used `x` with another concrete type, then we would end up inferring that.
Similarly, we can infer the types of the parameters with ease. By passing a parameter into *anything* that also has a type, we are saying “this and that has the same type.”
```
local function greetingsHelper(name: string)
return "Hello, " .. name
end
local function greetings(name)
return greetingsHelper(name)
end
print(greetings("Alexander")) -- ok
print(greetings({name = "Alexander"})) -- not ok
```
## Table types[Permalink](#table-types "Permalink")
From the type checker perspective, each table can be in one of three states. They are: `unsealed table`, `sealed table`, and `generic table`. This is intended to represent how the table’s type is allowed to change.
### Unsealed tables[Permalink](#unsealed-tables "Permalink")
An unsealed table is a table which supports adding new properties, which updates the tables type. Unsealed tables are created using table literals. This is one way to accumulate knowledge of the shape of this table.
```
local t = {x = 1} -- {x: number}
t.y = 2 -- {x: number, y: number}
t.z = 3 -- {x: number, y: number, z: number}
```
However, if this local were written as `local t: { x: number } = { x = 1 }`, it ends up sealing the table, so the two assignments henceforth will not be ok.
Furthermore, once we exit the scope where this unsealed table was created in, we seal it.
```
local function vec2(x, y)
local t = {}
t.x = x
t.y = y
return t
end
local v2 = vec2(1, 2)
v2.z = 3 -- not ok
```
Unsealed tables are *exact* in that any property of the table must be named by the type. Since Luau treats missing properties as having value `nil`, this means that we can treat an unsealed table which does not mention a property as if it mentioned the property, as long as that property is optional.
```
local t = {x = 1}
local u : { x : number, y : number? } = t -- ok because y is optional
local v : { x : number, z : number } = t -- not ok because z is not optional
```
### Sealed tables[Permalink](#sealed-tables "Permalink")
A sealed table is a table that is now locked down. This occurs when the table type is spelled out explicitly via a type annotation, or if it is returned from a function.
```
local t : { x: number } = {x = 1}
t.y = 2 -- not ok
```
Sealed tables are *inexact* in that the table may have properties which are not mentioned in the type.
As a result, sealed tables support *width subtyping*, which allows a table with more properties to be used as a table with fewer properties.
```
type Point1D = { x : number }
type Point2D = { x : number, y : number }
local p : Point2D = { x = 5, y = 37 }
local q : Point1D = p -- ok because Point2D has more properties than Point1D
```
### Generic tables[Permalink](#generic-tables "Permalink")
This typically occurs when the symbol does not have any annotated types or were not inferred anything concrete. In this case, when you index on a parameter, you’re requesting that there is a table with a matching interface.
```
local function f(t)
return t.x + t.y
--^ --^ {x: _, y: _}
end
f({x = 1, y = 2}) -- ok
f({x = 1, y = 2, z = 3}) -- ok
f({x = 1}) -- not ok
```
## Table indexers[Permalink](#table-indexers "Permalink")
These are particularly useful for when your table is used similarly to an array.
```
local t = {"Hello", "world!"} -- {[number]: string}
print(table.concat(t, ", "))
```
Luau supports a concise declaration for array\-like tables, `{T}` (for example, `{string}` is equivalent to `{[number]: string}`); the more explicit definition of an indexer is still useful when the key isn’t a number, or when the table has other fields like `{ [number]: string, n: number }`.
## Generics[Permalink](#generics "Permalink")
The type inference engine was built from the ground up to recognize generics. A generic is simply a type parameter in which another type could be slotted in. It’s extremely useful because it allows the type inference engine to remember what the type actually is, unlike `any`.
```
type Pair<T> = {first: T, second: T }
-- generics can also have defaults!
type PairWithDefault<T = string> = Pair<T>
local strings: Pair<string> = { first="Hello", second="World" }
local numbers: Pair<number> = { first=1, second=2 }
-- can just treat PairWithDefault as a type that doesnt have generics because it has all of its generics assigned a default!
local more_strings: PairWithDefault = { first = "meow", second = "mrrp" }
```
## Generic functions[Permalink](#generic-functions "Permalink")
As well as generic type aliases like `Pair<T>`, Luau supports generic functions. These are functions that, as well as their regular data parameters, take type parameters. For example, a function which reverses an array is:
```
function reverse(a)
local result = {}
for i = #a, 1, -1 do
table.insert(result, a[i])
end
return result
end
```
The type of this function is that it can reverse an array, and return an array of the same type. Luau can infer this type, but if you want to be explicit, you can declare the type parameter `T`, for example:
```
function reverse<T>(a: {T}): {T}
local result: {T} = {}
for i = #a, 1, -1 do
table.insert(result, a[i])
end
return result
end
```
When a generic function is called, Luau infers type arguments, for example
```
local x: {number} = reverse({1, 2, 3})
local y: {string} = reverse({"a", "b", "c"})
```
Generic types are used for built\-in functions as well as user functions,
for example the type of two\-argument `table.insert` is:
```
<T>({T}, T) -> ()
```
Note: Functions don’t support having defaults assigned to generics, meaning the following is invalid
```
function meow<T = string>(mrrp: T)
print(mrrp .. " :3")
end
```
## Union types[Permalink](#union-types "Permalink")
A union type represents *one of* the types in this set. If you try to pass a union onto another thing that expects a *more specific* type, it will fail.
For example, what if this `string | number` was passed into something that expects `number`, but the passed in value was actually a `string`?
```
local stringOrNumber: string | number = "foo"
local onlyString: string = stringOrNumber -- not ok
local onlyNumber: number = stringOrNumber -- not ok
```
Note: it’s impossible to be able to call a function if there are two or more function types in this union.
## Intersection types[Permalink](#intersection-types "Permalink")
An intersection type represents *all of* the types in this set. It’s useful for two main things: to join multiple tables together, or to specify overloadable functions.
```
type XCoord = {x: number}
type YCoord = {y: number}
type ZCoord = {z: number}
type Vector2 = XCoord & YCoord
type Vector3 = XCoord & YCoord & ZCoord
local vec2: Vector2 = {x = 1, y = 2} -- ok
local vec3: Vector3 = {x = 1, y = 2, z = 3} -- ok
```
```
type SimpleOverloadedFunction = ((string) -> number) & ((number) -> string)
local f: SimpleOverloadedFunction
local r1: number = f("foo") -- ok
local r2: number = f(12345) -- not ok
local r3: string = f("foo") -- not ok
local r4: string = f(12345) -- ok
```
Note: it’s impossible to create an intersection type of some primitive types, e.g. `string & number`, or `string & boolean`, or other variations thereof.
Note: Luau still does not support user\-defined overloaded functions. Some of Roblox and Lua 5\.1 functions have different function signature, so inherently requires overloaded functions.
## Singleton types (aka literal types)[Permalink](#singleton-types-aka-literal-types "Permalink")
Luau’s type system also supports singleton types, which means it’s a type that represents one single value at runtime. At this time, both string and booleans are representable in types.
> We do not currently support numbers as types. For now, this is intentional.
```
local foo: "Foo" = "Foo" -- ok
local bar: "Bar" = foo -- not ok
local baz: string = foo -- ok
local t: true = true -- ok
local f: false = false -- ok
```
This happens all the time, especially through [type refinements](#type-refinements) and is also incredibly useful when you want to enforce program invariants in the type system! See [tagged unions](#tagged-unions) for more information.
## Variadic types[Permalink](#variadic-types "Permalink")
Luau permits assigning a type to the `...` variadic symbol like any other parameter:
```
local function f(...: number)
end
f(1, 2, 3) -- ok
f(1, "string") -- not ok
```
`f` accepts any number of `number` values.
In type annotations, this is written as `...T`:
```
type F = (...number) -> ...string
```
## Type packs[Permalink](#type-packs "Permalink")
Multiple function return values as well as the function variadic parameter use a type pack to represent a list of types.
When a type alias is defined, generic type pack parameters can be used after the type parameters:
```
type Signal<T, U...> = { f: (T, U...) -> (), data: T }
```
> Keep in mind that `...T` is a variadic type pack (many elements of the same type `T`), while `U...` is a generic type pack that can contain zero or more types and they don’t have to be the same.
It is also possible for a generic function to reference a generic type pack from the generics list:
```
local function call<T, U...>(s: Signal<T, U...>, ...: U...)
s.f(s.data, ...)
end
```
Generic types with type packs can be instantiated by providing a type pack:
```
local signal: Signal<string, (number, number, boolean)> = --
call(signal, 1, 2, false)
```
There are also other ways to instantiate types with generic type pack parameters:
```
type A<T, U...> = (T) -> U...
type B = A<number, ...string> -- with a variadic type pack
type C<S...> = A<number, S...> -- with a generic type pack
type D = A<number, ()> -- with an empty type pack
```
Trailing type pack argument can also be provided without parentheses by specifying variadic type arguments:
```
type List<Head, Rest...> = (Head, Rest...) -> ()
type B = List<number> -- Rest... is ()
type C = List<number, string, boolean> -- Rest is (string, boolean)
type Returns<T...> = () -> T...
-- When there are no type parameters, the list can be left empty
type D = Returns<> -- T... is ()
```
Type pack parameters are not limited to a single one, as many as required can be specified:
```
type Callback<Args..., Rets...> = { f: (Args...) -> Rets... }
type A = Callback<(number, string), ...number>
```
## Adding types for faux object oriented programs[Permalink](#adding-types-for-faux-object-oriented-programs "Permalink")
One common pattern we see with existing Lua/Luau code is the following object\-oriented code. While Luau is capable of inferring a decent chunk of this code, it cannot pin down on the types of `self` when it spans multiple methods.
```
local Account = {}
Account.__index = Account
function Account.new(name, balance)
local self = {}
self.name = name
self.balance = balance
return setmetatable(self, Account)
end
-- The `self` type is different from the type returned by `Account.new`
function Account:deposit(credit)
self.balance += credit
end
-- The `self` type is different from the type returned by `Account.new`
function Account:withdraw(debit)
self.balance -= debit
end
local account = Account.new("Alexander", 500)
```
For example, the type of `Account.new` is `<a, b>(name: a, balance: b) -> { ..., name: a, balance: b, ... }` (snipping out the metatable). For better or worse, this means you are allowed to call `Account.new(5, "hello")` as well as `Account.new({}, {})`. In this case, this is quite unfortunate, so your first attempt may be to add type annotations to the parameters `name` and `balance`.
There’s the next problem: the type of `self` is not shared across methods of `Account`, this is because you are allowed to explicitly opt for a different value to pass as `self` by writing `account.deposit(another_account, 50)`. As a result, the type of `Account:deposit` is `<a, b>(self: { balance: a }, credit: b) -> ()`. Consequently, Luau cannot infer the result of the `+` operation from `a` and `b`, so a type error is reported.
We can see there’s a lot of problems happening here. This is a case where you’ll have to provide some guidance to Luau in the form of annotations today, but the process is straightforward and without repetition. You first specify the type of *data* you want your class to have, and then you define the class type separately with `setmetatable` (either via `typeof`, or in the New Type Solver, the `setmetatable` type function).
From then on, you can explicitly annotate the `self` type of each method with your class type! Note that while the definition is written e.g. `Account.deposit`, you can still call it as `account:deposit(...)`.
```
local Account = {}
Account.__index = Account
type AccountData = {
name: string,
balance: number,
}
export type Account = typeof(setmetatable({} :: AccountData, Account))
-- or alternatively, in the new type solver...
-- export type Account = setmetatable<AccountData, typeof(Account)>
-- this return annotation is not required, but ensures that you cannot
-- accidentally make the constructor incompatible with the methods
function Account.new(name, balance): Account
local self = {}
self.name = name
self.balance = balance
return setmetatable(self, Account)
end
-- this annotation on `self` is the only _required_ annotation.
function Account.deposit(self: Account, credit)
-- autocomplete on `self` works here!
self.balance += credit
end
-- this annotation on `self` is the only _required_ annotation.
function Account.withdraw(self: Account, debit)
-- autocomplete on `self` works here!
self.balance -= debit
end
local account = Account.new("Hina", 500)
account:deposit(20) -- this still works, and we had autocomplete after hitting `:`!
```
Based on feedback, we plan to restrict the types of all functions defined with `:` syntax to [share their self types](https://rfcs.luau.org/shared-self-types.html). This will enable future versions of this code to work without any explicit `self` annotations because it amounts to having type inference make precisely the assumptions we are encoding with annotations here — namely, that the type of the constructors and the method definitions is intended by the developer to be the same.
## Tagged unions[Permalink](#tagged-unions "Permalink")
Tagged unions are just union types! In particular, they’re union types of tables where they have at least *some* common properties but the structure of the tables are different enough. Here’s one example:
```
type Ok<T> = { type: "ok", value: T }
type Err<E> = { type: "err", error: E }
type Result<T, E> = Ok<T> | Err<E>
```
This `Result<T, E>` type can be discriminated by using type refinements on the property `type`, like so:
```
if result.type == "ok" then
-- result is known to be Ok<T>
-- and attempting to index for error here will fail
print(result.value)
elseif result.type == "err" then
-- result is known to be Err<E>
-- and attempting to index for value here will fail
print(result.error)
end
```
Which works out because `value: T` exists only when `type` is in actual fact `"ok"`, and `error: E` exists only when `type` is in actual fact `"err"`.
## Type refinements[Permalink](#type-refinements "Permalink")
When we check the type of any lvalue (a global, a local, or a property), what we’re doing is we’re refining the type, hence “type refinement.” The support for this is arbitrarily complex, so go at it!
Here are all the ways you can refine:
1. Truthy test: `if x then` will refine `x` to be truthy.
2. Type guards: `if type(x) == "number" then` will refine `x` to be `number`.
3. Equality: `if x == "hello" then` will refine `x` to be a singleton type `"hello"`.
And they can be composed with many of `and`/`or`/`not`. `not`, just like `~=`, will flip the resulting refinements, that is `not x` will refine `x` to be falsy.
The `assert(..)` function may also be used to refine types instead of `if/then`.
Using truthy test:
```
local maybeString: string? = nil
if maybeString then
local onlyString: string = maybeString -- ok
local onlyNil: nil = maybeString -- not ok
end
if not maybeString then
local onlyString: string = maybeString -- not ok
local onlyNil: nil = maybeString -- ok
end
```
Using `type` test:
```
local stringOrNumber: string | number = "foo"
if type(stringOrNumber) == "string" then
local onlyString: string = stringOrNumber -- ok
local onlyNumber: number = stringOrNumber -- not ok
end
if type(stringOrNumber) ~= "string" then
local onlyString: string = stringOrNumber -- not ok
local onlyNumber: number = stringOrNumber -- ok
end
```
Using equality test:
```
local myString: string = f()
if myString == "hello" then
local hello: "hello" = myString -- ok because it is absolutely "hello"!
local copy: string = myString -- ok
end
```
And as said earlier, we can compose as many of `and`/`or`/`not` as we wish with these refinements:
```
local function f(x: any, y: any)
if (x == "hello" or x == "bye") and type(y) == "string" then
-- x is of type "hello" | "bye"
-- y is of type string
end
if not (x ~= "hi") then
-- x is of type "hi"
end
end
```
`assert` can also be used to refine in all the same ways:
```
local stringOrNumber: string | number = "foo"
assert(type(stringOrNumber) == "string")
local onlyString: string = stringOrNumber -- ok
local onlyNumber: number = stringOrNumber -- not ok
```
## Type casts[Permalink](#type-casts "Permalink")
Expressions may be typecast using `::`. Typecasting is useful for specifying the type of an expression when the automatically inferred type is too generic.
For example, consider the following table constructor where the intent is to store a table of names:
```
local myTable = {names = {}}
table.insert(myTable.names, 42) -- Inserting a number ought to cause a type error, but doesn't
```
In order to specify the type of the `names` table a typecast may be used:
```
local myTable = {names = {} :: {string}}
table.insert(myTable.names, 42) -- not ok, invalid 'number' to 'string' conversion
```
A typecast itself is also type checked to ensure that one of the conversion operands is the subtype of the other or `any`:
```
local numericValue = 1
local value = numericValue :: any -- ok, all expressions may be cast to 'any'
local flag = numericValue :: boolean -- not ok, invalid 'number' to 'boolean' conversion
```
When typecasting a variadic or the result of a function with multiple returns, only the first value will be preserved. The rest will be discarded.
```
function returnsMultiple(...): (number, number, number)
print(... :: string) -- "x"
return 1, 2, 3
end
print(returnsMultiple("x", "y", "z")) -- 1, 2, 3
print(returnsMultiple("x", "y", "z") :: number) -- 1
```
## Roblox types[Permalink](#roblox-types "Permalink")
Roblox supports a rich set of classes and data types, [documented here](https://developer.roblox.com/en-us/api-reference). All of them are readily available for the type checker to use by their name (e.g. `Part` or `RaycastResult`).
When one type inherits from another type, the type checker models this relationship and allows to cast a subclass to the parent class implicitly, so you can pass a `Part` to a function that expects an `Instance`.
All enums are also available to use by their name as part of the `Enum` type library, e.g. `local m: Enum.Material = part.Material`.
We can automatically deduce what calls like `Instance.new` and `game:GetService` are supposed to return:
```
local part = Instance.new("Part")
local basePart: BasePart = part
```
Finally, Roblox types can be refined using `IsA`:
```
local function getText(x : Instance) : string
if x:IsA("TextLabel") or x:IsA("TextButton") or x:IsA("TextBox") then
return child.Text
end
return ""
end
```
Note that many of these types provide some properties and methods in both lowerCase and UpperCase; the lowerCase variants are deprecated, and the type system will ask you to use the UpperCase variants instead.
## Module interactions[Permalink](#module-interactions "Permalink")
Let’s say that we have two modules, `Foo` and `Bar`. Luau will try to resolve the paths if it can find any `require` in any scripts. In this case, when you say `script.Parent.Bar`, Luau will resolve it as: relative to this script, go to my parent and get that script named Bar.
```
-- Module Foo
local Bar = require(script.Parent.Bar)
local baz1: Bar.Baz = 1 -- not ok
local baz2: Bar.Baz = "foo" -- ok
print(Bar.Quux) -- ok
print(Bar.FakeProperty) -- not ok
Bar.NewProperty = true -- not ok
```
```
-- Module Bar
export type Baz = string
local module = {}
module.Quux = "Hello, world!"
return module
```
There are some caveats here though. For instance, the require path must be resolvable statically, otherwise Luau cannot accurately type check it.
### Cyclic module dependencies[Permalink](#cyclic-module-dependencies "Permalink")
Cyclic module dependencies can cause problems for the type checker. In order to break a module dependency cycle a typecast of the module to `any` may be used:
```
local myModule = require(MyModule) :: any
```
## Type functions[Permalink](#type-functions "Permalink")
Type functions are functions that run during analysis time and operate on types, instead of runtime values. They can use the [types](#types-library) library to transform existing types or create new ones.
Here’s a simplified implementation of the builtin type function `keyof`. It takes a table type and returns its property names as a [union](typecheck#union-types) of [singletons](typecheck#singleton-types-aka-literal-types).
```
type function simple_keyof(ty)
-- Ignoring unions or intersections of tables for simplicity.
if not ty:is("table") then
error("Can only call keyof on tables.")
end
local union = nil
for property in ty:properties() do
union = if union then types.unionof(union, property) else property
end
return if union then union else types.singleton(nil)
end
type person = {
name: string,
age: number,
}
--- keys = "age" | "name"
type keys = simple_keyof<person>
```
### Type function environment[Permalink](#type-function-environment "Permalink")
In addition to the [types](#types-library) library, type functions have access to:
* `assert`, `error`, `print`
* `next`, `ipairs`, `pairs`
* `select`, `unpack`
* `getmetatable`, `setmetatable`
* `rawget`, `rawset`, `rawlen`, `raweq`
* `tonumber`, `tostring`
* `type`, `typeof`
* `math` library
* `table` library
* `string` library
* `bit32` library
* `utf8` library
* `buffer` library
## types library[Permalink](#types-library "Permalink")
The `types` library is used to create and transform types, and can only be used within [type functions](#type-functions).
### `types` library properties[Permalink](#types-library-properties "Permalink")
```
types.any
```
The [any](typecheck#any-type) `type`.
```
types.unknown
```
The [unknown](typecheck#unknown-type) `type`.
```
types.never
```
The [never](typecheck#never-type) `type`.
```
types.boolean
```
The boolean `type`.
```
types.buffer
```
The [buffer](library#buffer-library) `type`.
```
types.number
```
The number `type`.
```
types.string
```
The string `type`.
```
types.thread
```
The thread `type`.
## `types` library functions[Permalink](#types-library-functions "Permalink")
```
types.singleton(arg: string | boolean | nil): type
```
Returns the [singleton](typecheck#singleton-types-aka-literal-types) type of the argument.
```
types.negationof(arg: type): type
```
Returns an immutable negation of the argument type.
```
types.optional(arg: type): type
```
Returns a version of the given type that is now optional.
* If the given type is a [union type]((typecheck#union-types)), `nil` will be added unconditionally as a component.
* Otherwise, the result will be a union of the given type and the `nil` type.
```
types.unionof(first: type, second: type, ...: type): type
```
Returns an immutable [union](typecheck#union-types) of two or more arguments.
```
types.intersectionof(first: type, second: type, ...: type): type
```
Returns an immutable [intersection](typecheck#intersection-types) of two or more arguments.
```
types.newtable(props: { [type]: type | { read: type?, write: type? } }?, indexer: { index: type, readresult: type, writeresult: type? }?, metatable: type?): type
```
Returns a fresh, mutable table `type`. Property keys must be string singleton `type`s. The table’s metatable is set if one is provided.
```
types.newfunction(parameters: { head: {type}?, tail: type? }, returns: { head: {type}?, tail: type? }?, generics: {type}?): type
```
Returns a fresh, mutable function `type`, using the ordered parameters of `head` and the variadic tail of `tail`.
```
types.copy(arg: type): type
```
Returns a deep copy of the argument type.
```
types.generic(name: string?, ispack: boolean?): type
```
Creates a [generic](typecheck#generic-functions) named `name`. If `ispack` is `true`, the result is a [generic pack](typecheck#type-packs).
### `type` instance[Permalink](#type-instance "Permalink")
`type` instances can have extra properties and methods described in subsections depending on its tag.
```
type.tag: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "string" | "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "class" | "thread" | "buffer"
```
An immutable property holding the type’s tag.
```
__eq(arg: type): boolean
```
Overrides the `==` operator to return `true` if `self` is syntactically equal to `arg`. This excludes semantically equivalent types, `true | false` is unequal to `boolean`.
```
type:is(arg: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "string" | "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "class" | "thread" | "buffer")
```
Returns `true` if `self` has the argument as its tag.
### Singleton `type` instance[Permalink](#singleton-type-instance "Permalink")
```
singletontype:value(): boolean | nil | "string"
```
Returns the singleton’s actual value, like `true` for `types.singleton(true)`.
### Generic `type` instance[Permalink](#generic-type-instance "Permalink")
```
generictype:name(): string?
```
Returns the name of the [generic](typecheck#generic-functions) or `nil` if it has no name.
```
generictype:ispack(): boolean
```
Returns `true` if the [generic](typecheck#generic-functions) is a [pack](typecheck#type-packs), or `false` otherwise.
### Table `type` instance[Permalink](#table-type-instance "Permalink")
```
tabletype:setproperty(key: type, value: type?)
```
Sets the type of the property for the given `key`, using the same type for both reading from and writing to the table.
* `key` is expected to be a string singleton type, naming the property.
* `value` will be set as both the `read type` and `write type` of the property.
* If `value` is `nil`, the property is removed.
```
tabletype:setreadproperty(key: type, value: type?)
```
Sets the type for reading from the property named by `key`, leaving the type for writing this property as\-is.
* `key` is expected to be a string singleton type, naming the property.
* `value` will be set as the `read type`, the `write type` will be unchanged.
* If `key` is not already present, only a `read type` will be set, making the property read\-only.
* If `value` is `nil`, the property is removed.
```
tabletype:setwriteproperty(key: type, value: type?)
```
Sets the type for writing to the property named by `key`, leaving the type for reading this property as\-is.
* `key` is expected to be a string singleton type, naming the property.
* `value` will be set as the `write type`, the `read type` will be unchanged.
* If `key` is not already present, only a `write type` will be set, making the property write\-only.
* If `value` is `nil`, the property is removed.
```
tabletype:readproperty(key: type): type?
```
Returns the type used for reading values from this property, or `nil` if the property doesn’t exist.
```
tabletype:writeproperty(key: type): type?
```
Returns the type used for writing values to this property, or `nil` if the property doesn’t exist.
```
tabletype:properties(): { [type]: { read: type?, write: type? } }
```
Returns a table mapping property keys to their read and write types.
```
tabletype:setindexer(index: type, result: type)
```
Sets the table’s indexer, using the same type for reads and writes.
```
tabletype:setreadindexer(index: type, result: type)
```
Sets the type resulting from reading from this table via indexing.
```
tabletype:setwriteindexer(index: type, result: type)
```
Sets the type for writing to this table via indexing.
```
tabletype:indexer(): { index: type, readresult: type, writeresult: type }
```
Returns the table’s indexer as a table, or `nil` if it doesn’t exist.
```
tabletype:readindexer(): { index: type, result: type }?
```
Returns the table’s indexer using the result’s read type, or `nil` if it doesn’t exist.
```
tabletype:writeindexer()
```
Returns the table’s indexer using the result’s write type, or `nil` if it doesn’t exist.
```
tabletype:setmetatable(arg: type)
```
Sets the table’s metatable.
```
tabletype:metatable(): type?
```
Gets the table’s metatable, or `nil` if it doesn’t exist.
### Function `type` instance[Permalink](#function-type-instance "Permalink")
```
functiontype:setparameters(head: {type}?, tail: type?)
```
Sets the function’s parameters, with the ordered parameters in `head` and the variadic tail in `tail`.
```
functiontype:parameters(): { head: {type}?, tail: type? }
```
Returns the function’s parameters, with the ordered parameters in `head` and the variadic tail in `tail`.
```
functiontype:setreturns(head: {type}?, tail: type?)
```
Sets the function’s return types, with the ordered parameters in `head` and the variadic tail in `tail`.
```
functiontype:returns(): { head: {type}?, tail: type? }
```
Returns the function’s return types, with the ordered parameters in `head` and the variadic tail in `tail`.
```
functiontype:generics(): {type}
```
Returns an array of the function’s [generic](typecheck#generic-functions) `type`s.
```
functiontype:setgenerics(generics: {type}?)
```
Sets the function’s [generic](typecheck#generic-functions) `type`s.
### Negation `type` instance[Permalink](#negation-type-instance "Permalink")
```
type:inner(): type
```
Returns the `type` being negated.
### Union `type` instance[Permalink](#union-type-instance "Permalink")
```
uniontype:components(): {type}
```
Returns an array of the [unioned](typecheck#union-types) types.
### Intersection `type` instance[Permalink](#intersection-type-instance "Permalink")
```
intersectiontype:components()
```
Returns an array of the [intersected](typecheck#intersection-types) types.
### Class `type` instance[Permalink](#class-type-instance "Permalink")
```
classtype:properties(): { [type]: { read: type?, write: type? } }
```
Returns the properties of the class with their respective `read` and `write` types.
```
classtype:readparent(): type?
```
Returns the type of reading this class’ parent, or returns `nil` if the parent class doesn’t exist.
```
classtype:writeparent(): type?
```
Returns the type for writing to this class’ parent, or returns `nil` if the parent class doesn’t exist.
```
classtype:metatable(): type?
```
Returns the class’ metatable, or `nil` if it doesn’t exist.
```
classtype:indexer(): { index: type, readresult: type, writeresult: type }?
```
Returns the class’ indexer, or `nil` if it doesn’t exist.
```
classtype:readindexer(): { index: type, result: type }?
```
Returns result type of reading from the class via indexing, or `nil` if it doesn’t exist.
```
classtype:writeindexer(): { index: type, result: type }?
```
Returns the type for writing to the class via indexing, or `nil` if it doesn’t exist.
| 7 |
https://luau.org/profile
|
en-us
|
# Profiling
#### On this page
One of main goals of Luau is to enable high performance code. To help with that goal, we are relentlessly optimizing the compiler and runtime \- but ultimately, performance of their
code is in developers’ hands, and is a combination of good algorithm design and implementation that adheres to the strengths of the language. To help write efficient code, Luau
provides a built\-in profiler that samples the execution of the program and outputs a profiler dump that can be converted to an interactive flamegraph.
To run the profiler, make sure you have an optimized build of the interpreter (otherwise profiling results are going to be very skewed) and run it with `--profile` argument:
```
$ luau --profile tests/chess.lua
OK 8902 rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
OK 2039 r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 0
OK 2812 8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 0
OK 9467 r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1
OK 1486 rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8
OK 2079 r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 10
Profiler dump written to profile.out (total runtime 2.034 seconds, 20344 samples, 374 stacks)
GC: 0.378 seconds (18.58%), mark 46.80%, remark 3.33%, atomic 1.93%, sweepstring 6.77%, sweep 41.16%
```
The resulting `profile.out` file can be converted to an SVG file by running `perfgraph.py` script that is part of Luau repository:
```
$ python tools/perfgraph.py profile.out >profile.svg
```
This produces an SVG file that can be opened in a browser (the image below is clickable):
[](/assets/images/chess-profile.svg)
In a flame graph visualization, the individual bars represent function calls, the width represents how much of the total program runtime they execute, and the nesting matches the call stack encountered during program execution. This is a fantastic visualization technique that allows you to hone in on the specific bottlenecks affecting
your program performance, optimize those exact bottlenecks, and then re\-generate the profile data and visualizer, and look for the next set of true bottlenecks (if any).
Hovering your mouse cursor over individual sections will display detailed function information in the status bar and in a tooltip. If you want to Search for a specific named
function, use the Search field in the upper right, or press Ctrl\+F.
Notice that some of the bars in the screenshot don’t have any text. In some cases, there isn’t enough room in the size of the bar to display the name.
You can hover your mouse over those bars to see the name and source location of the function in the tool tip, or double\-click to zoom in on that part of the flame graph.
Some tooltips will have a source location for the function you’re hovering over, but no name. Those are anonymous functions, or functions that were not declared in a way that
allows Luau compiler to track the name. To fill in more names, you may want to make these changes to your code:
`local myFunc = function() --[[ work ]] end` \-\> `local function myFunc() --[[ work ]] end`
Even without these changes, you can hover over a given bar with no visible name and see it’s source location.
As any sampling profiler, this profiler relies on gathering enough information for the resulting output to be statistically meaningful. It may miss short functions if they
aren’t called often enough. By default the profiler runs at 10 kHz, this can be customized by passing a different parameter to `--profile=`. Note that higher
frequencies result in higher profiling overhead and longer program execution, potentially skewing the results.
This profiler doesn’t track leaf C functions and instead attributes the time spent there to calling Luau functions. As a result, when thinking about why a given function is
slow, consider not just the work it does immediately but also the library functions it calls.
This profiler tracks time consumed by Luau thread stacks; when a thread calls another thread via `coroutine.resume`, the time spent is not attributed to the parent thread that’s
waiting for resume results. This limitation will be removed in the future.
| 8 |
https://luau.org/library
|
en-us
|
# Library
#### On this page
* [Global functions](#global-functions)
* [math library](#math-library)
* [table library](#table-library)
* [string library](#string-library)
* [coroutine library](#coroutine-library)
* [bit32 library](#bit32-library)
* [utf8 library](#utf8-library)
* [os library](#os-library)
* [debug library](#debug-library)
* [buffer library](#buffer-library)
* [vector library](#vector-library)
Luau comes equipped with a standard library of functions designed to manipulate the built\-in data types. Note that the library is relatively minimal and doesn’t expose ways for
scripts to interact with the host environment \- it’s expected that embedding applications provide extra functionality on top of this and limit or sandbox the system access
appropriately, if necessary. For example, Roblox provides [a rich API to interact with the 3D environment and limited APIs to interact with external services](https://developer.roblox.com/en-us/api-reference).
This page documents the available builtin libraries and functions. All of these are accessible by default by any script, assuming the host environment exposes them (which is usually a safe assumption outside of extremely constrained environments).
## Global functions[Permalink](#global-functions "Permalink")
While most library functions are provided as part of a library like `table`, a few global functions are exposed without extra namespacing.
```
function assert<T>(value: T, message: string?): T
```
`assert` checks if the value is truthy; if it’s not (which means it’s `false` or `nil`), it raises an error. The error message can be customized with an optional parameter.
Upon success the function returns the `value` argument.
```
function error(obj: any, level: number?)
```
`error` raises an error with the specified object. Note that errors don’t have to be strings, although they often are by convention; various error handling mechanisms like `pcall`preserve the error type. When `level` is specified, the error raised is turned into a string that contains call frame information for the caller at level `level`, where `1` refers
to the function that called `error`. This can be useful to attribute the errors to callers, for example `error("Expected a valid object", 2)` highlights the caller of the function
that called `error` instead of the function itself in the callstack.
```
function gcinfo(): number
```
`gcinfo` returns the total heap size in kilobytes, which includes bytecode objects, global tables as well as the script\-allocated objects. Note that Luau uses an incremental
garbage collector, and as such at any given point in time the heap may contain both reachable and unreachable objects. The number returned by `gcinfo` reflects the current heap
consumption from the operating system perspective and can fluctuate over time as garbage collector frees objects.
```
function getfenv(target: (function | number)?): table
```
Returns the environment table for target function; when `target` is not a function, it must be a number corresponding to the caller stack index, where 1 means the function that calls `getfenv`, and the environment table is returned for the corresponding function from the call stack. When `target` is omitted it defaults to `1`, so `getfenv()` returns the environment table for the calling function.
```
function getmetatable(obj: any): table?
```
Returns the metatable for the specified object; when object is not a table or a userdata, the returned metatable is shared between all objects of the same type. Note that when metatable is protected (has a `__metatable` key), the value corresponding to that key is returned instead and may not be a table.
```
function next<K, V>(t: { [K]: V }, i: K?): (K, V)?
```
Given the table `t`, returns the next key\-value pair after `i` in the table traversal order, or nothing if `i` is the last key. When `i` is `nil`, returns the first key\-value pair instead.
```
function newproxy(mt: boolean?): userdata
```
Creates a new untyped userdata object; when `mt` is true, the new object has an empty metatable that can be modified using `getmetatable`.
```
function print(args: ...any)
```
Prints all arguments to the standard output, using Tab as a separator.
```
function rawequal(a: any, b: any): boolean
```
Returns true iff `a` and `b` have the same type and point to the same object (for garbage collected types) or are equal (for value types).
```
function rawget<K, V>(t: { [K]: V }, k: K): V?
```
Performs a table lookup with index `k` and returns the resulting value, if present in the table, or nil. This operation bypasses metatables/`__index`.
```
function rawset<K, V>(t: { [K] : V }, k: K, v: V)
```
Assigns table field `k` to the value `v`. This operation bypasses metatables/`__newindex`.
```
function select<T>(i: string, args: ...T): number
function select<T>(i: number, args: ...T): ...T
```
When called with `'#'` as the first argument, returns the number of remaining parameters passed. Otherwise, returns the subset of parameters starting with the specified index.
Index can be specified from the start of the arguments (using 1 as the first argument), or from the end (using \-1 as the last argument).
```
function setfenv(target: function | number, env: table)
```
Changes the environment table for target function to `env`; when `target` is not a function, it must be a number corresponding to the caller stack index, where 1 means the function that calls `setfenv`, and the environment table is returned for the corresponding function from the call stack.
```
function setmetatable(t: table, mt: table?)
```
Changes metatable for the given table. Note that unlike `getmetatable`, this function only works on tables. If the table already has a protected metatable (has a `__metatable` field), this function errors.
```
function tonumber(s: string, base: number?): number?
```
Converts the input string to the number in base `base` (default 10\) and returns the resulting number. If the conversion fails (that is, if the input string doesn’t represent a valid number in the specified base), returns `nil` instead.
```
function tostring(obj: any): string
```
Converts the input object to string and returns the result. If the object has a metatable with `__tostring` field, that method is called to perform the conversion.
```
function type(obj: any): string
```
Returns the type of the object, which is one of `"nil"`, `"boolean"`, `"number"`, `"vector"`, `"string"`, `"table"`, `"function"`, `"userdata"`, `"thread"`, or `"buffer"`.
```
function typeof(obj: any): string
```
Returns the type of the object; for userdata objects that have a metatable with the `__type` field *and* are defined by the host (not `newproxy`), returns the value for that key.
For custom userdata objects, such as ones returned by `newproxy`, this function returns `"userdata"` to make sure host\-defined types can not be spoofed.
```
function ipairs(t: table): <iterator>
```
Returns the triple (generator, state, nil) that can be used to traverse the table using a `for` loop. The traversal results in key\-value pairs for the numeric portion of the table; key starts from 1 and increases by 1 on each iteration. The traversal terminates when reaching the first `nil` value (so `ipairs` can’t be used to traverse array\-like tables with holes).
```
function pairs(t: table): <iterator>
```
Returns the triple (generator, state, nil) that can be used to traverse the table using a `for` loop. The traversal results in key\-value pairs for all keys in the table, numeric and otherwise, but doesn’t have a defined order.
```
function pcall(f: function, args: ...any): (boolean, ...any)
```
Calls function `f` with parameters `args`. If the function succeeds, returns `true` followed by all return values of `f`. If the function raises an error, returns `false` followed by the error object.
Note that `f` can yield, which results in the entire coroutine yielding as well.
```
function xpcall(f: function, e: function, args: ...any): (boolean, ...any)
```
Calls function `f` with parameters `args`. If the function succeeds, returns `true` followed by all return values of `f`. If the function raises an error, calls `e` with the error object as an argument, and returns `false` followed by all return values of `e`.
Note that `f` can yield, which results in the entire coroutine yielding as well.`e` can neither yield nor error \- if it does raise an error, `xpcall` returns with `false` followed by a special error message.
```
function unpack<V>(a: {V}, f: number?, t: number?): ...V
```
Returns all values of `a` with indices in `[f..t]` range. `f` defaults to 1 and `t` defaults to `#a`. Note that this is equivalent to `table.unpack`.
## math library[Permalink](#math-library "Permalink")
```
function math.abs(n: number): number
```
Returns the absolute value of `n`. Returns NaN if the input is NaN.
```
function math.acos(n: number): number
```
Returns the arc cosine of `n`, expressed in radians. Returns a value in `[0, pi]` range. Returns NaN if the input is not in `[-1, +1]` range.
```
function math.asin(n: number): number
```
Returns the arc sine of `n`, expressed in radians. Returns a value in `[-pi/2, +pi/2]` range. Returns NaN if the input is not in `[-1, +1]` range.
```
function math.atan2(y: number, x: number): number
```
Returns the arc tangent of `y/x`, expressed in radians. The function takes into account the sign of both arguments in order to determine the quadrant. Returns a value in `[-pi, pi]` range.
```
function math.atan(n: number): number
```
Returns the arc tangent of `n`, expressed in radians. Returns a value in `[-pi/2, pi-2]` range.
```
function math.ceil(n: number): number
```
Rounds `n` upwards to the next integer boundary.
```
function math.cosh(n: number): number
```
Returns the hyperbolic cosine of `n`.
```
function math.cos(n: number): number
```
Returns the cosine of `n`, which is an angle in radians. Returns a value in `[0, 1]` range.
```
function math.deg(n: number): number
```
Converts `n` from radians to degrees and returns the result.
```
function math.exp(n: number): number
```
Returns the base\-e exponent of `n`, that is `e^n`.
```
function math.floor(n: number): number
```
Rounds `n` downwards to previous integer boundary.
```
function math.fmod(x: number, y: number): number
```
Returns the remainder of `x` modulo `y`, rounded towards zero. Returns NaN if `y` is zero.
```
function math.frexp(n: number): (number, number)
```
Splits the number into a significand (a number in `[-1, +1]` range) and binary exponent such that `n = s * 2^e`, and returns `s, e`.
```
function math.ldexp(s: number, e: number): number
```
Given the significand and a binary exponent, returns a number `s * 2^e`.
```
function math.lerp(a: number, b: number, t: number): number
```
Linearly interpolated between number value `a` and `b` using factor `t`, generally returning the result of `a + (b - a) * t`.
When `t` is exactly `1`, the value of `b` will be returned instead to ensure that when `t` is on the interval `[0, 1]`, the result of `lerp` will be on the interval `[a, b]`.
```
math.map(x: number, inmin: number, inmax: number, outmin: number, outmax: number): number
```
Returns a value that represents `x` mapped linearly from the input range (`inmin` to `inmax`) to the output range (`outmin` to `outmax`).
```
function math.log10(n: number): number
```
Returns base\-10 logarithm of the input number. Returns NaN if the input is negative, and negative infinity if the input is 0\.
Equivalent to `math.log(n, 10)`.
```
function math.log(n: number, base: number?): number
```
Returns logarithm of the input number in the specified base; base defaults to `e`. Returns NaN if the input is negative, and negative infinity if the input is 0\.
```
function math.max(list: ...number): number
```
Returns the maximum number of the input arguments. The function requires at least one input and will error if zero parameters are passed. If one of the inputs is a NaN, the result may or may not be a NaN.
```
function math.min(list: ...number): number
```
Returns the minimum number of the input arguments. The function requires at least one input and will error if zero parameters are passed. If one of the inputs is a NaN, the result may or may not be a NaN.
```
function math.modf(n: number): (number, number)
```
Returns the integer and fractional part of the input number. Both the integer and fractional part have the same sign as the input number, e.g. `math.modf(-1.5)` returns `-1, -0.5`.
```
function math.pow(x: number, y: number): number
```
Returns `x` raised to the power of `y`.
```
function math.rad(n: number): number
```
Converts `n` from degrees to radians and returns the result.
```
function math.random(): number
function math.random(n: number): number
function math.random(min: number, max: number): number
```
Returns a random number using the global random number generator. A zero\-argument version returns a number in `[0, 1]` range. A one\-argument version returns a number in `[1, n]` range. A two\-argument version returns a number in `[min, max]` range. The input arguments are truncated to integers, so `math.random(1.5)` always returns 1\.
```
function math.randomseed(seed: number)
```
Reseeds the global random number generator; subsequent calls to `math.random` will generate a deterministic sequence of numbers that only depends on `seed`.
```
function math.sinh(n: number): number
```
Returns a hyperbolic sine of `n`.
```
function math.sin(n: number): number
```
Returns the sine of `n`, which is an angle in radians. Returns a value in `[0, 1]` range.
```
function math.sqrt(n: number): number
```
Returns the square root of `n`. Returns NaN if the input is negative.
```
function math.tanh(n: number): number
```
Returns the hyperbolic tangent of `n`.
```
function math.tan(n: number): number
```
Returns the tangent of `n`, which is an angle in radians.
```
function math.noise(x: number, y: number?, z: number?): number
```
Returns 3D Perlin noise value for the point `(x, y, z)` (`y` and `z` default to zero if absent). Returns a value in `[-1, 1]` range.
```
function math.clamp(n: number, min: number, max: number): number
```
Returns `n` if the number is in `[min, max]` range; otherwise, returns `min` when `n < min`, and `max` otherwise. If `n` is NaN, may or may not return NaN.
The function errors if `min > max`.
```
function math.sign(n: number): number
```
Returns `-1` if `n` is negative, `1` if `n` is positive, and `0` if `n` is zero or NaN.
```
function math.round(n: number): number
```
Rounds `n` to the nearest integer boundary. If `n` is exactly halfway between two integers, rounds `n` away from 0\.
## table library[Permalink](#table-library "Permalink")
```
function table.concat(a: {string}, sep: string?, f: number?, t: number?): string
```
Concatenate all elements of `a` with indices in range `[f..t]` together, using `sep` as a separator if present. `f` defaults to 1 and `t` defaults to `#a`.
```
function table.foreach<K, V, R>(t: { [K]: V }, f: (K, V) -> R?): R?
```
Iterates over all elements of the table in unspecified order; for each key\-value pair, calls `f` and returns the result of `f` if it’s non\-nil. If all invocations of `f` returned `nil`, returns no values. This function has been deprecated and is not recommended for use in new code; use `for` loop instead.
```
function table.foreachi<V, R>(t: {V}, f: (number, V) -> R?): R?
```
Iterates over numeric keys of the table in `[1..#t]` range in order; for each key\-value pair, calls `f` and returns the result of `f` if it’s non\-nil. If all invocations of `f` returned `nil`, returns no values. This function has been deprecated and is not recommended for use in new code; use `for` loop instead.
```
function table.getn<V>(t: {V}): number
```
Returns the length of table `t`. This function has been deprecated and is not recommended for use in new code; use `#t` instead.
```
function table.maxn<V>(t: {V}): number
```
Returns the maximum numeric key of table `t`, or zero if the table doesn’t have numeric keys.
```
function table.insert<V>(t: {V}, v: V)
function table.insert<V>(t: {V}, i: number, v: V)
```
When using a two\-argument version, appends the value to the array portion of the table (equivalent to `t[#t+1] = v`).
When using a three\-argument version, inserts the value at index `i` and shifts values at indices after that by 1\. `i` should be in `[1..#t]` range.
```
function table.remove<V>(t: {V}, i: number?): V?
```
Removes element `i` from the table and shifts values at indices after that by 1\. If `i` is not specified, removes the last element of the table.`i` should be in `[1..#t]` range.
Returns the value of the removed element, or `nil` if no element was removed (e.g. table was empty).
```
function table.sort<V>(t: {V}, f: ((V, V) -> boolean)?)
```
Sorts the table `t` in ascending order, using `f` as a comparison predicate: `f` should return `true` iff the first parameter should be before the second parameter in the resulting table. When `f` is not specified, builtin less\-than comparison is used instead.
The comparison predicate must establish a strict weak ordering \- sort results are undefined otherwise.
```
function table.pack<V>(args: ...V): { [number]: V, n: number }
```
Returns a table that consists of all input arguments as array elements, and `n` field that is set to the number of inputs.
```
function table.unpack<V>(a: {V}, f: number?, t: number?): ...V
```
Returns all values of `a` with indices in `[f..t]` range. `f` defaults to 1 and `t` defaults to `#a`.
Note that if you want to unpack varargs packed with `table.pack` you have to specify the index fields because `table.unpack` doesn’t automatically use the `n` field that `table.pack` creates. Example usage for packed varargs: `table.unpack(args, 1, args.n)`
```
function table.move<V>(a: {V}, f: number, t: number, d: number, tt: {V}?)
```
Copies elements in range `[f..t]` from table `a` to table `tt` if specified and `a` otherwise, starting from the index `d`.
```
function table.create<V>(n: number, v: V?): {V}
```
Creates a table with `n` elements; all of them (range `[1..n]`) are set to `v`. When `v` is nil or omitted, the returned table is empty but has preallocated space for `n` elements which can make subsequent insertions faster.
Note that preallocation is only performed for the array portion of the table \- using `table.create` on dictionaries is counter\-productive.
```
function table.find<V>(t: {V}, v: V, init: number?): number?
```
Find the first element in the table that is equal to `v` and returns its index; the traversal stops at the first `nil`. If the element is not found, `nil` is returned instead. The traversal starts at index `init` if specified, otherwise 1\.
```
function table.clear(t: table)
```
Removes all elements from the table while preserving the table capacity, so future assignments don’t need to reallocate space.
```
function table.freeze(t: table): table
```
Given a non\-frozen table, freezes it such that all subsequent attempts to modify the table or assign its metatable raise an error. If the input table is already frozen or has a protected metatable, the function raises an error; otherwise it returns the input table.
Note that the table is frozen in\-place and is not being copied. Additionally, only `t` is frozen, and keys/values/metatable of `t` don’t change their state and need to be frozen separately if desired.
```
function table.isfrozen(t: table): boolean
```
Returns `true` iff the input table is frozen.
```
function table.clone(t: table): table
```
Returns a copy of the input table that has the same metatable, same keys and values, and is not frozen even if `t` was.
The copy is shallow: implementing a deep recursive copy automatically is challenging, and often only certain keys need to be cloned recursively which can be done after the initial clone by modifying the resulting table.
## string library[Permalink](#string-library "Permalink")
```
function string.byte(s: string, f: number?, t: number?): ...number
```
Returns the numeric code of every byte in the input string with indices in range `[f..t]`. `f` defaults to 1 and `t` defaults to `f`, so a two\-argument version of this function returns a single number. If the function is called with a single argument and the argument is out of range, the function returns no values.
```
function string.char(args: ...number): string
```
Returns the string that contains a byte for every input number; all inputs must be integers in `[0..255]` range.
```
function string.find(s: string, p: string, init: number?, plain: boolean?): (number?, number?, ...string)
```
Tries to find an instance of pattern `p` in the string `s`, starting from position `init` (defaults to 1\). When `plain` is true, the search is using raw (case\-sensitive) string equality, otherwise `p` should be a [string pattern](https://www.lua.org/manual/5.3/manual.html#6.4.1). If a match is found, returns the position of the match and the length of the match, followed by the pattern captures; otherwise returns `nil`.
```
function string.format(s: string, args: ...any): string
```
Returns a formatted version of the input arguments using a [printf\-style format string](https://en.cppreference.com/w/c/io/fprintf) `s`. The following format characters are supported:
* `c`: expects an integer number and produces a character with the corresponding character code
* `d`, `i`, `u`: expects an integer number and produces the decimal representation of that number
* `o`: expects an integer number and produces the octal representation of that number
* `x`, `X`: expects an integer number and produces the hexadecimal representation of that number, using lower case or upper case hexadecimal characters
* `e`, `E`, `f`, `g`, `G`: expects a number and produces the floating point representation of that number, using scientific or decimal representation
* `q`: expects a string and produces the same string quoted using double quotation marks, with escaped special characters if necessary
* `s`: expects a string and produces the same string verbatim
The formats support modifiers `-`, `+`, space, `#` and `0`, as well as field width and precision modifiers \- with the exception of `*`.
```
function string.gmatch(s: string, p: string): <iterator>
```
Produces an iterator function that, when called repeatedly explicitly or via `for` loop, produces matches of string `s` with [string pattern](https://www.lua.org/manual/5.3/manual.html#6.4.1) `p`. For every match, the captures within the pattern are returned if present (if a pattern has no captures, the entire matching substring is returned instead).
```
function string.gsub(s: string, p: string, f: function | table | string, maxs: number?): (string, number)
```
For every match of [string pattern](https://www.lua.org/manual/5.3/manual.html#6.4.1) `p` in `s`, replace the match according to `f`. The substitutions stop after the limit of `maxs`, and the function returns the resulting string followed by the number of substitutions.
When `f` is a string, the substitution uses the string as a replacement. When `f` is a table, the substitution uses the table element with key corresponding to the first pattern capture, if present, and entire match otherwise. Finally, when `f` is a function, the substitution uses the result of calling `f` with call pattern captures, or entire matching substring if no captures are present.
```
function string.len(s: string): number
```
Returns the number of bytes in the string (equivalent to `#s`).
```
function string.lower(s: string): string
```
Returns a string where each byte corresponds to the lower\-case ASCII version of the input byte in the source string.
```
function string.match(s: string, p: string, init: number?): ...string?
```
Tries to find an instance of pattern `p` in the string `s`, starting from position `init` (defaults to 1\). `p` should be a [string pattern](https://www.lua.org/manual/5.3/manual.html#6.4.1). If a match is found, returns all pattern captures, or entire matching substring if no captures are present, otherwise returns `nil`.
```
function string.rep(s: string, n: number): string
```
Returns the input string `s` repeated `n` times. Returns an empty string if `n` is zero or negative.
```
function string.reverse(s: string): string
```
Returns the string with the order of bytes reversed compared to the original. Note that this only works if the input is a binary or ASCII string.
```
function string.sub(s: string, f: number, t: number?): string
```
Returns a substring of the input string with the byte range `[f..t]`; `t` defaults to `#s`, so a two\-argument version returns a string suffix.
```
function string.upper(s: string): string
```
Returns a string where each byte corresponds to the upper\-case ASCII version of the input byte in the source string.
```
function string.split(s: string, sep: string?): {string}
```
Splits the input string using `sep` as a separator (defaults to `","`) and returns the resulting substrings. If separator is empty, the input string is split into separate one\-byte strings.
```
function string.pack(f: string, args: ...any): string
```
Given a [pack format string](https://www.lua.org/manual/5.3/manual.html#6.4.2), encodes all input parameters according to the packing format and returns the resulting string. Note that Luau uses fixed sizes for all types that have platform\-dependent size in Lua 5\.x: short is 16 bit, long is 64 bit, integer is 32\-bit and size\_t is 32 bit for the purpose of string packing.
```
function string.packsize(f: string): number
```
Given a [pack format string](https://www.lua.org/manual/5.3/manual.html#6.4.2), returns the size of the resulting packed representation. The pack format can’t use variable\-length format specifiers. Note that Luau uses fixed sizes for all types that have platform\-dependent size in Lua 5\.x: short is 16 bit, long is 64 bit, integer is 32\-bit and size\_t is 32 bit for the purpose of string packing.
```
function string.unpack(f: string, s: string): ...any
```
Given a [pack format string](https://www.lua.org/manual/5.3/manual.html#6.4.2), decodes the input string according to the packing format and returns all resulting values. Note that Luau uses fixed sizes for all types that have platform\-dependent size in Lua 5\.x: short is 16 bit, long is 64 bit, integer is 32\-bit and size\_t is 32 bit for the purpose of string packing.
## coroutine library[Permalink](#coroutine-library "Permalink")
```
function coroutine.create(f: function): thread
```
Returns a new coroutine that, when resumed, will run function `f`.
```
function coroutine.running(): thread?
```
Returns the currently running coroutine, or `nil` if the code is running in the main coroutine (depending on the host environment setup, main coroutine may never be used for running code).
```
function coroutine.status(co: thread): string
```
Returns the status of the coroutine, which can be `"running"`, `"suspended"`, `"normal"` or `"dead"`. Dead coroutines have finished their execution and can not be resumed, but their state can still be inspected as they are not dead from the garbage collector point of view.
```
function coroutine.wrap(f: function): function
```
Creates a new coroutine and returns a function that, when called, resumes the coroutine and passes all arguments along to the suspension point. When the coroutine yields or finishes, the wrapped function returns with all values returned at the suspension point.
```
function coroutine.yield(args: ...any): ...any
```
Yields the currently running coroutine and passes all arguments along to the code that resumed the coroutine. The coroutine becomes suspended; when the coroutine is resumed again, the resumption arguments will be forwarded to `yield` which will behave as if it returned all of them.
```
function coroutine.isyieldable(): boolean
```
Returns `true` iff the currently running coroutine can yield. Yielding is prohibited when running inside metamethods like `__index` or C functions like `table.foreach` callback, with the exception of `pcall`/`xpcall`.
```
function coroutine.resume(co: thread, args: ...any): (boolean, ...any)
```
Resumes the coroutine and passes the arguments along to the suspension point. When the coroutine yields or finishes, returns `true` and all values returned at the suspension point. If an error is raised during coroutine resumption, this function returns `false` and the error object, similarly to `pcall`.
```
function coroutine.close(co: thread): (boolean, any?)
```
Closes the coroutine which puts coroutine in the dead state. The coroutine must be dead or suspended \- in particular it can’t be currently running. If the coroutine that’s being closed was in an error state, returns `false` along with an error object; otherwise returns `true`. After closing, the coroutine can’t be resumed and the coroutine stack becomes empty.
## bit32 library[Permalink](#bit32-library "Permalink")
All functions in the `bit32` library treat input numbers as 32\-bit unsigned integers in `[0..4294967295]` range. The bit positions start at 0 where 0 corresponds to the least significant bit.
```
function bit32.arshift(n: number, i: number): number
```
Shifts `n` by `i` bits to the right (if `i` is negative, a left shift is performed instead). The most significant bit of `n` is propagated during the shift. When `i` is larger than 31, returns an integer with all bits set to the sign bit of `n`. When `i` is smaller than `-31`, 0 is returned.
```
function bit32.band(args: ...number): number
```
Performs a bitwise `and` of all input numbers and returns the result. If the function is called with no arguments, an integer with all bits set to 1 is returned.
```
function bit32.bnot(n: number): number
```
Returns a bitwise negation of the input number.
```
function bit32.bor(args: ...number): number
```
Performs a bitwise `or` of all input numbers and returns the result. If the function is called with no arguments, zero is returned.
```
function bit32.bxor(args: ...number): number
```
Performs a bitwise `xor` (exclusive or) of all input numbers and returns the result. If the function is called with no arguments, zero is returned.
```
function bit32.btest(args: ...number): boolean
```
Perform a bitwise `and` of all input numbers, and return `true` iff the result is not 0\. If the function is called with no arguments, `true` is returned.
```
function bit32.extract(n: number, f: number, w: number?): number
```
Extracts bits of `n` at position `f` with a width of `w`, and returns the resulting integer. `w` defaults to `1`, so a two\-argument version of `extract` returns the bit value at position `f`. Bits are indexed starting at 0\. Errors if `f` and `f+w-1` are not between 0 and 31\.
```
function bit32.lrotate(n: number, i: number): number
```
Rotates `n` to the left by `i` bits (if `i` is negative, a right rotate is performed instead); the bits that are shifted past the bit width are shifted back from the right.
```
function bit32.lshift(n: number, i: number): number
```
Shifts `n` to the left by `i` bits (if `i` is negative, a right shift is performed instead). When `i` is outside of `[-31..31]` range, returns 0\.
```
function bit32.replace(n: number, r: number, f: number, w: number?): number
```
Replaces bits of `n` at position `f` and width `w` with `r`, and returns the resulting integer. `w` defaults to `1`, so a three\-argument version of `replace` changes one bit at position `f` to `r` (which should be 0 or 1\) and returns the result. Bits are indexed starting at 0\. Errors if `f` and `f+w-1` are not between 0 and 31\.
```
function bit32.rrotate(n: number, i: number): number
```
Rotates `n` to the right by `i` bits (if `i` is negative, a left rotate is performed instead); the bits that are shifted past the bit width are shifted back from the left.
```
function bit32.rshift(n: number, i: number): number
```
Shifts `n` to the right by `i` bits (if `i` is negative, a left shift is performed instead). When `i` is outside of `[-31..31]` range, returns 0\.
```
function bit32.countlz(n: number): number
```
Returns the number of consecutive zero bits in the 32\-bit representation of `n` starting from the left\-most (most significant) bit. Returns 32 if `n` is zero.
```
function bit32.countrz(n: number): number
```
Returns the number of consecutive zero bits in the 32\-bit representation of `n` starting from the right\-most (least significant) bit. Returns 32 if `n` is zero.
```
function bit32.byteswap(n: number): number
```
Returns `n` with the order of the bytes swapped.
## utf8 library[Permalink](#utf8-library "Permalink")
Strings in Luau can contain arbitrary bytes; however, in many applications strings representing text contain UTF8 encoded data by convention, that can be inspected and manipulated using `utf8` library.
```
function utf8.offset(s: string, n: number, i: number?): number?
```
Returns the byte offset of the Unicode codepoint number `n` in the string, starting from the byte position `i`. When the character is not found, returns `nil` instead.
```
function utf8.codepoint(s: string, i: number?, j: number?): ...number
```
Returns a number for each Unicode codepoint in the string with the starting byte offset in `[i..j]` range. `i` defaults to 1 and `j` defaults to `i`, so a two\-argument version of this function returns the Unicode codepoint that starts at byte offset `i`.
```
function utf8.char(args: ...number): string
```
Creates a string by concatenating Unicode codepoints for each input number.
```
function utf8.len(s: string, i: number?, j: number?): number?
```
Returns the number of Unicode codepoints with the starting byte offset in `[i..j]` range, or `nil` followed by the first invalid byte position if the input string is malformed.`i` defaults to 1 and `j` defaults to `#s`, so `utf8.len(s)` returns the number of Unicode codepoints in string `s` or `nil` if the string is malformed.
```
function utf8.codes(s: string): <iterator>
```
Returns an iterator that, when used in `for` loop, produces the byte offset and the codepoint for each Unicode codepoints that `s` consists of.
## os library[Permalink](#os-library "Permalink")
```
function os.clock(): number
```
Returns a high\-precision timestamp (in seconds) that doesn’t have a defined baseline, but can be used to measure duration with sub\-microsecond precision.
```
function os.date(s: string?, t: number?): table | string
```
Returns the table or string representation of the time specified as `t` (defaults to current time) according to `s` format string.
When `s` starts with `!`, the result uses UTC, otherwise it uses the current timezone.
If `s` is equal to `*t` (or `!*t`), a table representation of the date is returned, with keys `sec`/`min`/`hour` for the time (using 24\-hour clock), `day`/`month`/`year` for the date, `wday` for week day (1\..7\), `yday` for year day (1\..366\) and `isdst` indicating whether the timezone is currently using daylight savings.
Otherwise, `s` is interpreted as a [date format string](https://www.cplusplus.com/reference/ctime/strftime/), with the valid specifiers including any of `aAbBcdHIjmMpSUwWxXyYzZ` or `%`. `s` defaults to `"%c"` so `os.date()` returns the human\-readable representation of the current date in local timezone.
```
function os.difftime(a: number, b: number): number
```
Calculates the difference in seconds between `a` and `b`; provided for compatibility only. Please use `a - b` instead.
```
function os.time(t: table?): number
```
When called without arguments, returns the current date/time as a Unix timestamp. When called with an argument, expects it to be a table that contains `sec`/`min`/`hour`/`day`/`month`/`year` keys and returns the Unix timestamp of the specified date/time in UTC.
## debug library[Permalink](#debug-library "Permalink")
```
function debug.info(co: thread, level: number, s: string): ...any
function debug.info(level: number, s: string): ...any
function debug.info(f: function, s: string): ...any
```
Given a stack frame or a function, and a string that specifies the requested information, returns the information about the stack frame or function.
Each character of `s` results in additional values being returned in the same order as the characters appear in the string:
* `s` returns source path for the function
* `l` returns the line number for the stack frame or the line where the function is defined when inspecting a function object
* `n` returns the name of the function, or an empty string if the name is not known
* `f` returns the function object itself
* `a` returns the number of arguments that the function expects followed by a boolean indicating whether the function is variadic or not
For example, `debug.info(2, "sln")` returns source file, current line and function name for the caller of the current function.
```
function debug.traceback(co: thread, msg: string?, level: number?): string
function debug.traceback(msg: string?, level: number?): string
```
Produces a stringified callstack of the given thread, or the current thread, starting with level `level`. If `msg` is specified, then the resulting callstack includes the string before the callstack output, separated with a newline. The format of the callstack is human\-readable and subject to change.
## buffer library[Permalink](#buffer-library "Permalink")
Buffer is an object that represents a fixed\-size mutable block of memory.
All operations on a buffer are provided using the ‘buffer’ library functions.
Many of the functions accept an offset in bytes from the start of the buffer.
Offset of 0 from the start of the buffer memory block accesses the first byte.
All offsets, counts and sizes should be non\-negative integer numbers.
If the bytes that are accessed by any read or write operation are outside the buffer memory, an error is thrown.
```
function buffer.create(size: number): buffer
```
Creates a buffer of the requested size with all bytes initialized to 0\.
Size limit is 1GB or 1,073,741,824 bytes.
```
function buffer.fromstring(str: string): buffer
```
Creates a buffer initialized to the contents of the string.
The size of the buffer equals to the length of the string.
```
function buffer.tostring(b: buffer): string
```
Returns the buffer data as a string.
```
function buffer.len(b: buffer): number
```
Returns the size of the buffer in bytes.
```
function buffer.readi8(b: buffer, offset: number): number
function buffer.readu8(b: buffer, offset: number): number
function buffer.readi16(b: buffer, offset: number): number
function buffer.readu16(b: buffer, offset: number): number
function buffer.readi32(b: buffer, offset: number): number
function buffer.readu32(b: buffer, offset: number): number
function buffer.readf32(b: buffer, offset: number): number
function buffer.readf64(b: buffer, offset: number): number
```
Used to read the data from the buffer by reinterpreting bytes at the offset as the type in the argument and converting it into a number.
Available types:
| Function | Type | Range |
| --- | --- | --- |
| readi8 | signed 8\-bit integer | \[\-128, 127] |
| readu8 | unsigned 8\-bit integer | \[0, 255] |
| readi16 | signed 16\-bit integer | \[\-32,768, 32,767] |
| readu16 | unsigned 16\-bit integer | \[0, 65,535] |
| readi32 | signed 32\-bit integer | \[\-2,147,483,648, 2,147,483,647] |
| readu32 | unsigned 32\-bit integer | \[0, 4,294,967,295] |
| readf32 | 32\-bit floating\-point number | Single\-precision IEEE 754 number |
| readf64 | 64\-bit floating\-point number | Double\-precision IEEE 754 number |
Floating\-point numbers are read and written using a format specified by IEEE 754\.
If a floating\-point value matches any of bit patterns that represent a NaN (not a number), returned value might be converted to a different quiet NaN representation.
Read and write operations use the little endian byte order.
Integer numbers are read and written using two’s complement representation.
```
function buffer.writei8(b: buffer, offset: number, value: number): ()
function buffer.writeu8(b: buffer, offset: number, value: number): ()
function buffer.writei16(b: buffer, offset: number, value: number): ()
function buffer.writeu16(b: buffer, offset: number, value: number): ()
function buffer.writei32(b: buffer, offset: number, value: number): ()
function buffer.writeu32(b: buffer, offset: number, value: number): ()
function buffer.writef32(b: buffer, offset: number, value: number): ()
function buffer.writef64(b: buffer, offset: number, value: number): ()
```
Used to write data to the buffer by converting the number into the type in the argument and reinterpreting it as individual bytes.
Ranges of acceptable values can be seen in the table above.
When writing integers, the number is converted using `bit32` library rules.
Values that are out\-of\-range will take less significant bits of the full number.
For example, writing 43,981 (0xabcd) using writei8 function will take 0xcd and interpret it as an 8\-bit signed number \-51\.
It is still recommended to keep all numbers in range of the target type.
Results of converting special number values (inf/nan) to integers are platform\-specific.
```
function buffer.readstring(b: buffer, offset: number, count: number): string
```
Used to read a string of length ‘count’ from the buffer at specified offset.
```
function buffer.writestring(b: buffer, offset: number, value: string, count: number?): ()
```
Used to write data from a string into the buffer at a specified offset.
If an optional ‘count’ is specified, only ‘count’ bytes are taken from the string.
Count cannot be larger than the string length.
```
buffer.readbits(b: buffer, bitOffset: number, bitCount: number): number
```
Used to read a range of `bitCount` bits from the buffer, at specified offset `bitOffset`, into an unsigned integer.
`bitCount` must be in `[0, 32]` range.
```
buffer.writebits(b: buffer, bitOffset: number, bitCount: number, value: number): ()
```
Used to write `bitCount` bits from `value` into the buffer at specified offset `bitOffset`.
`bitCount` must be in `[0, 32]` range.
```
function buffer.copy(target: buffer, targetOffset: number, source: buffer, sourceOffset: number?, count: number?): ()
```
Copy ‘count’ bytes from ‘source’ starting at offset ‘sourceOffset’ into the ‘target’ at ‘targetOffset’.
It is possible for ‘source’ and ‘target’ to be the same. Copying an overlapping region inside the same buffer acts as if the source region is copied into a temporary buffer and then that buffer is copied over to the target.
If ‘sourceOffset’ is nil or is omitted, it defaults to 0\.
If ‘count’ is ‘nil’ or is omitted, the whole ‘source’ data starting from ‘sourceOffset’ is copied.
```
function buffer.fill(b: buffer, offset: number, value: number, count: number?): ()
```
Sets the ‘count’ bytes in the buffer starting at the specified ‘offset’ to the ‘value’.
If ‘count’ is ‘nil’ or is omitted, all bytes from the specified offset until the end of the buffer are set.
## vector library[Permalink](#vector-library "Permalink")
This library implements functionality for the vector type in addition to the built\-in primitive operator support.
Default configuration uses vectors with 3 components (`x`, `y`, and `z`).
If the *4\-wide mode* is enabled by setting the `LUA_VECTOR_SIZE` VM configuration to 4, vectors get an additional `w` component.
Individual vector components can be accessed using the fields `x` or `X`, `y` or `Y`, `z` or `Z`, and `w` or `W` in 4\-wide mode.
Since vector values are immutable, writes to individual components are not supported.
```
vector.zero
vector.one
```
Constant vectors with all components set to 0 and 1 respectively. Includes the fourth component in *4\-wide mode*.
```
vector.create(x: number, y: number, z: number): vector
vector.create(x: number, y: number, z: number, w: number): vector
```
Creates a new vector with the given component values. The first constructor sets the fourth (`w`) component to 0\.0 in *4\-wide mode*.
```
vector.magnitude(vec: vector): number
```
Calculates the magnitude of a given vector. Includes the fourth component in *4\-wide mode*.
```
vector.normalize(vec: vector): vector
```
Computes the normalized version (unit vector) of a given vector. Includes the fourth component in *4\-wide mode*.
```
vector.cross(vec1: vector, vec2: vector): vector
```
Computes the cross product of two vectors. Ignores the fourth component in *4\-wide mode* and returns the 3\-dimensional cross product.
```
vector.dot(vec1: vector, vec2: vector): number
```
Computes the dot product of two vectors. Includes the fourth component in *4\-wide mode*.
```
vector.angle(vec1: vector, vec2: vector, axis: vector?): number
```
Computes the angle between two vectors in radians. The axis, if specified, is used to determine the sign of the angle. Ignores the fourth component in *4\-wide mode* and returns the 3\-dimensional angle.
```
vector.floor(vec: vector): vector
```
Applies `math.floor` to every component of the input vector. Includes the fourth component in *4\-wide mode*.
```
vector.ceil(vec: vector): vector
```
Applies `math.ceil` to every component of the input vector. Includes the fourth component in *4\-wide mode*.
```
vector.abs(vec: vector): vector
```
Applies `math.abs` to every component of the input vector. Includes the fourth component in *4\-wide mode*.
```
vector.sign(vec: vector): vector
```
Applies `math.sign` to every component of the input vector. Includes the fourth component in *4\-wide mode*.
```
vector.clamp(vec: vector, min: vector, max: vector): vector
```
Applies `math.clamp` to every component of the input vector. Includes the fourth component in *4\-wide mode*.
```
vector.max(...: vector): vector
```
Applies `math.max` to the corresponding components of the input vectors. Includes the fourth component in *4\-wide mode*. Equivalent to `vector.create(math.max((...).x), math.max((...).y), math.max((...).z), math.max((...).w))`.
```
vector.min(...: vector): vector
```
Applies `math.min` to the corresponding components of the input vectors. Includes the fourth component in *4\-wide mode*. Equivalent to `vector.create(math.min((...).x), math.min((...).y), math.min((...).z), math.min((...).w))`.
| 9 |
https://luau.org/grammar
|
en-us
|
# Grammar
This is the complete syntax grammar for Luau in EBNF. More information about the terminal nodes STRING and NUMBER
is available in the [syntax section](syntax).
```
chunk ::= block
block ::= {stat [';']} [laststat [';']]
stat ::= varlist '=' explist |
var compoundop exp |
functioncall |
'do' block 'end' |
'while' exp 'do' block 'end' |
'repeat' block 'until' exp |
'if' exp 'then' block {'elseif' exp 'then' block} ['else' block] 'end' |
'for' binding '=' exp ',' exp [',' exp] 'do' block 'end' |
'for' bindinglist 'in' explist 'do' block 'end' |
attributes 'function' funcname funcbody |
attributes 'local' 'function' NAME funcbody |
'local' bindinglist ['=' explist] |
['export'] 'type' NAME ['<' GenericTypeListWithDefaults '>'] '=' Type |
['export'] 'type' 'function' NAME funcbody
laststat ::= 'return' [explist] | 'break' | 'continue'
funcname ::= NAME {'.' NAME} [':' NAME]
funcbody ::= ['<' GenericTypeList '>'] '(' [parlist] ')' [':' ReturnType] block 'end'
parlist ::= bindinglist [',' '...' [':' (GenericTypePack | Type)]] | '...' [':' (GenericTypePack | Type)]
explist ::= {exp ','} exp
binding ::= NAME [':' Type]
bindinglist ::= binding [',' bindinglist] (* equivalent of Lua 5.1 'namelist', except with optional type annotations *)
var ::= NAME | prefixexp '[' exp ']' | prefixexp '.' NAME
varlist ::= var {',' var}
prefixexp ::= var | functioncall | '(' exp ')'
functioncall ::= prefixexp funcargs | prefixexp ':' NAME funcargs
exp ::= asexp { binop exp } | unop exp { binop exp }
ifelseexp ::= 'if' exp 'then' exp {'elseif' exp 'then' exp} 'else' exp
asexp ::= simpleexp ['::' Type]
stringinterp ::= INTERP_BEGIN exp { INTERP_MID exp } INTERP_END
simpleexp ::= NUMBER | STRING | 'nil' | 'true' | 'false' | '...' | tableconstructor | attributes 'function' funcbody | prefixexp | ifelseexp | stringinterp
funcargs ::= '(' [explist] ')' | tableconstructor | STRING
tableconstructor ::= '{' [fieldlist] '}'
fieldlist ::= field {fieldsep field} [fieldsep]
field ::= '[' exp ']' '=' exp | NAME '=' exp | exp
fieldsep ::= ',' | ';'
compoundop ::= '+=' | '-=' | '*=' | '/=' | '//=' | '%=' | '^=' | '..='
binop ::= '+' | '-' | '*' | '/' | '//' | '^' | '%' | '..' | '<' | '<=' | '>' | '>=' | '==' | '~=' | 'and' | 'or'
unop ::= '-' | 'not' | '#'
littable ::= '{' [litfieldlist] '}'
litfieldlist ::= litfield {fieldsep litfield} [fieldsep]
litfield ::= [NAME '='] literal
literal ::= 'nil' | 'false' | 'true' | NUMBER | STRING | littable
litlist ::= literal {',' literal}
pars ::= '(' [litlist] ')' | littable | STRING
parattr ::= NAME [pars]
attribute ::= '@' NAME | '@[' parattr {',' parattr} ']'
attributes ::= {attribute}
SimpleType ::=
'nil' |
SingletonType |
NAME ['.' NAME] [ '<' [TypeParams] '>' ] |
'typeof' '(' exp ')' |
TableType |
FunctionType |
'(' Type ')'
SingletonType ::= STRING | 'true' | 'false'
Union ::= [SimpleType {'?'}] {'|' SimpleType {'?'}}
Intersection ::= [SimpleType] {'&' SimpleType}
Type ::= Union | Intersection
GenericTypePackParameter ::= NAME '...'
GenericTypeList ::= NAME [',' GenericTypeList] | GenericTypePackParameter {',' GenericTypePackParameter}
GenericTypePackParameterWithDefault ::= NAME '...' '=' (TypePack | VariadicTypePack | GenericTypePack)
GenericTypeListWithDefaults ::=
NAME ['=' Type] [',' GenericTypeListWithDefaults] |
GenericTypePackParameterWithDefault {',' GenericTypePackParameterWithDefault}
TypeList ::= Type [',' TypeList] | '...' Type
BoundTypeList ::= [NAME ':'] Type [',' BoundTypeList] | GenericTypePack | VariadicTypePack
TypeParams ::= (Type | TypePack | VariadicTypePack | GenericTypePack) [',' TypeParams]
TypePack ::= '(' [TypeList] ')'
GenericTypePack ::= NAME '...'
VariadicTypePack ::= '...' Type
ReturnType ::= Type | TypePack | GenericTypePack | VariadicTypePack
TableIndexer ::= ['read' | 'write'] '[' Type ']' ':' Type
TableProp ::= ['read' | 'write'] NAME ':' Type
PropList ::= TableProp [fieldsep PropList] | TableIndexer {fieldsep TableProp}
TableType ::= '{' Type '}' | '{' [PropList] '}'
FunctionType ::= ['<' GenericTypeList '>'] '(' [BoundTypeList] ')' '->' ReturnType
```
| 10 |
https://create.roblox.com/docs
|
en-us
|
[
14:54Polish your environmentFinalize your assets, spruce up your terrain, add effects, and oh my.RobloxLearn](https://www.youtube.com/watch?v=4kasDMSDvcQ)[
8:00Find and fix memory leaksLearn how to use the LuauHeap tool to keep an eye on memory usage.RobloxLearn](https://www.youtube.com/watch?v=x1JgsC8c8VQ)[
7:50Using the SmoothDamp methodKeep your transitions smooth even when the target value changes.RobloxLearn](https://www.youtube.com/watch?v=RYzj4TjiMyE)[
15:03Lighting and terrainTake a deep dive into lighting your environment and adding terrain.RobloxLearn](https://www.youtube.com/watch?v=XgkmKxyRuWE)[
2:42Rewarded video adsLearn how to implement rewarded video ads in your experiences.RobloxLearn](https://www.youtube.com/watch?v=Jpj0VnA-jmI)[
9:15Work with remote eventsWhen should you consider using an UnreliableRemoteEvent?RobloxLearn](https://www.youtube.com/watch?v=n5uOVlCIUjI)[Bans dashboardManage your permanent and temporary bans from Creator Hub.](https://create.roblox.com/docs/production/bans)[
10:08It's about time()Learn about all the best methods for telling time in Roblox experiences.RobloxLearn](https://www.youtube.com/watch?v=VE56HDVNibI)[
12:19Grayboxing environmentsLearn best practices for blocking out your environments.RobloxLearn](https://www.youtube.com/watch?v=T--CNfkfBBQ)[
11:08Using the Studio debuggerAn in\-depth look at how to debug your code in Roblox Studio.RobloxLearn](https://www.youtube.com/watch?v=yOmPc2g8tbY)[
11:24Luau and OOPObject\-oriented programming in Luau. When does it make sense?RobloxLearn](https://www.youtube.com/watch?v=fByFKZarNiI)[
8:34Simplify development with UI stylesUse the new Style Manager to create, manage, and apply UI styles.RobloxLearn](https://www.youtube.com/watch?v=_k1ea0OIKaU)[
5:41ModuleScript basicsLearn how module scripts work and when to use them.RobloxLearn](https://www.youtube.com/watch?v=foKFpXZYXPk)[
6:23Build an MMO with data storesUse data stores to save player progress and handle player position.RobloxLearn](https://www.youtube.com/watch?v=PeIZN7tPutg)[
14:10How to make shoes for RobloxMake and sell your first pair of shoes on Roblox.RobloxLearn](https://www.youtube.com/watch?v=NHgYM78afqc)[
9:58Performance optimization basicsLearn how to deal with the most common performance problems.RobloxLearn](https://www.youtube.com/watch?v=VDO_amtWfDw)[
9:37UGC insights ft. Reverse\_Polarity and Madison\_Hatter2Learn how to sell and promote avatar items with insights from the experts.RobloxLearn](https://www.youtube.com/watch?v=Zb1BJow0NV4)[
55:46Intro to modeling for UGC ft. Reverse\_PolarityLearn efficient workflows for making avatar items in Blender.RobloxLearn](https://www.youtube.com/watch?v=b0ugFLxrPIU)[
36:47Intro to texturing for UGC ft. Madison\_Hatter2Madison\_Hatter2 shows how to texture and publish a simple avatar item.RobloxLearn](https://www.youtube.com/watch?v=MlyJD_ix9CE)[
7:33How to get your code to run on RobloxAndrew shows you where to place your scripts, so they run properly.RobloxLearn](https://www.youtube.com/watch?v=Mdgk49Evink)[Tailor Swiftly \- Dynamic cloth in RobloxMar 26, 2025PrinceTybalt](https://devforum.roblox.com/t/3577035)[
22:08Enyu opens Studio for the first timeMinty teaches Enyu about constructive solid geometry.RobloxLearn](https://www.youtube.com/watch?v=lAKBYXLkNGU)[
1:02:27CagingLearn how to cage your avatar items from Roblox's own 3D artistRobloxLearn](https://www.youtube.com/watch?v=QwZaA9Gc-WQ)[
6:42PolarCub's UGC HomestoreLet's tour PolarCub's UGC Homestore! Also, Temprist shows up.RobloxLearn](https://www.youtube.com/watch?v=0k4o_fGNOYQ)[
6:03Advanced MicroProfiler UsageDive deep into frame colors, flame graphs, and moreRobloxLearn](https://www.youtube.com/watch?v=eWf-6Sh-9Os)[
2:34:56Halloween Game JamJoin our incredible cast of creators for a Halloween game jamRobloxLearn](https://www.youtube.com/watch?v=VCqopgaVthA)[
4:27How to use the MicroProfilerGet started with the performance optimization and troubleshooting toolRobloxLearn](https://www.youtube.com/watch?v=XLCZfGEm9tU)[MicroProfiler memory profiling, flame graphs, diffs, and much moreOct 23, 2024ZenMa1n](https://devforum.roblox.com/t/3226801)[Real world building and scripting optimization for RobloxAug 19, 2024MrChickenRocket](https://devforum.roblox.com/t/3127146)[
15:00ClothingMake and sell your first basic clothing item on RobloxRobloxLearn](https://www.youtube.com/watch?v=C-DwGRBHvmE)[
12:22Create an Accessory in MinutesMake and sell your first basic rigid accessory on RobloxRobloxLearn](https://www.youtube.com/watch?v=Eed29gV0hLA)[
1:55:43Intro to World BuildingStaff stream covering parts, meshes, terrain, and lightingRobloxLearn](https://www.youtube.com/watch?v=SgPU84AqpkY&t=286s)[
1:00:12Intro to Modeling in BlenderLearn basic modeling techniques in blenderRobloxLearn](https://www.youtube.com/live/fFHlrTAGwxw)[Integrating External Applications into your UI DesignNov 18, 2024peachcoolish](https://devforum.roblox.com/t/3266163)[Check out the generative AI stream and let us know your best prompts!Oct 14, 2024Slim\_Fandango](https://devforum.roblox.com/t/3215844)[YOU Should use Packages. Yes, YOU!Oct 3, 2024SCHLEEMPH](https://devforum.roblox.com/t/3182086)[Texture Atlases \- Creating Foliage Texture and MeshesSep 23, 2024SCHLEEMPH](https://devforum.roblox.com/t/3171224)[Trim Textures \- 3D Modeling and Unwrapping Trim SheetsSep 23, 2024SCHLEEMPH](https://devforum.roblox.com/t/3171223)[Roblox Chat builds an obby, and you can too!Sep 2, 2024DucksAreYeIIow](https://devforum.roblox.com/t/3145609)[Designing UI \- Tips and Best PracticesJul 16, 2024uiuxartist](https://devforum.roblox.com/t/3074034)[Improving Onboarding through Funnel EventsJul 11, 2024BreakfastCandy](https://devforum.roblox.com/t/3064458)
## Browse the Docs
[Experiences](/docs/experiences)[Get Started](/docs/experiences)[Tutorials](/docs/tutorials)[Examples](/docs/samples)[Engine API Reference](/docs/reference/engine)[Studio](/docs/studio)[Avatar](/docs/avatar)[Get Started](/docs/avatar)[Accessories](/docs/art/accessories)[Clothing](/docs/art/accessories/layered-clothing)[Characters](/docs/art/characters)[Publishing and Selling](/docs/marketplace/publish-to-marketplace)[Assets](/docs/assets)[Get Started](/docs/assets)[3D Art](/docs/art)[Open Cloud](/docs/cloud)[API Reference](/docs/cloud/reference)[Guides](/docs/cloud/guides)[Scale](/docs/scale)[Overview](/docs/scale)[Discovery](/docs/discovery)[Localization](/docs/production/localization)[Analytics](/docs/production/analytics)[Game Design](/docs/production/game-design)[Monetize](/docs/monetize)[Overview](/docs/monetize)[Experiences](/docs/monetize-experiences)[Avatar](/docs/monetize-avatar)[Assets](/docs/production/sell-on-creator-store)
| 11 |
https://create.roblox.com/docs/id-id/cloud
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Open Cloud](/docs/id-id/cloud)
Bahasa Indonesia
Masukan
# Referensi API cloud
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/cloud).
Dengan Open Cloud, Anda dapat mengakses sumber daya Roblox melalui API [REST](https://en.wikipedia.org/wiki/REST) standar, yang memungkinkan Anda membangun semuanya mulai dari alat otomatisasi baris perintah hingga aplikasi web yang kompleks.API Cloud Terbuka mendukung HTTPS dan menggunakan [kunci API](/docs/id-id/cloud/auth/api-keys) atau [OAuth 2\.0](/docs/id-id/cloud/auth/oauth2-overview) untuk autentikasi.Anda dapat memperbarui pengalaman, memulai ulang server, bekerja dengan penyimpanan data dan penyimpanan memori, mengelola batasan pengguna, daftar item inventaris, dan banyak lagi.
## [Tentang referensi ini](#tentang-referensi-ini)
Dokumentasi referensi ini terbagi menjadi dua bagian:
* Bagian berbasis fitur [yang mengkategorikan API berdasarkan kasus penggunaan (Avatar, Game Pass, Pengguna, dll)](/docs/id-id/cloud/features/accounts)
* Sebagian [yang memisahkan akhiran oleh sistem](/docs/id-id/cloud/reference/DataStore#Cloud_ListDataStores) (Open Cloud v2, v1, atau warisan).Kedua bagian berisi daftar lengkap akhir API yang tersedia; gunakan yang mana pun yang membantu Anda menemukan apa yang Anda butuhkan.
Sewaktu mungkin, gunakan Open Cloud v2, Open Cloud v1, atau [akhiran lama yang mendukung kunci API dan/atau autentikasi OAuth 2\.0](/docs/id-id/cloud/legacy) .API ini memiliki jaminan stabilitas yang kuat dan secara teratur menambahkan sumber daya baru.
Akhir API lama dengan otentikasi cookie dapat mencakup perubahan yang melanggar tanpa pemberitahuan dan memiliki jaminan stabilitas minimal.Kami tidak merekomendasikan mereka untuk aplikasi produksi.API warisan telah dikenal dengan berbagai nama selama bertahun\-tahun, termasuk API situs Roblox, API web, dan API klasik.
Roblox juga menawarkan [webhook](/docs/id-id/cloud/webhooks/webhook-notifications), yang dapat memberi tahu aplikasi Anda ketika terjadi peristiwa tertentu, seperti pengembalian atau perubahan langganan.
## [Mulai dengan Open Cloud](#mulai-dengan-open-cloud)
1. Konfigurasi autentikasi untuk aplikasi Anda.
Lihat dokumentasi tentang cara menggunakan [kunci API](/docs/id-id/cloud/auth/api-keys) atau [OAuth 2\.0](/docs/id-id/cloud/auth/oauth2-overview). Kunci API adalah cara termudah untuk memulai.
2. Tes panggilan API menggunakan alat seperti [Postman](https://www.postman.com) dengan [deskripsi OpenAPI](/docs/id-id/cloud/reference/openapi) atau aplikasi sampel [OAuth 2\.0](/docs/id-id/cloud/auth/oauth2-sample).
3. Ulas kembali [panduan sumber daya](/docs/id-id/cloud/guides) untuk tur lintas akhir menggunakan API tertentu.
4. Jelajahi navigasi kiri untuk daftar lengkap sumber daya Open Cloud v2 dan v1, [pola API umum](/docs/id-id/cloud/reference/patterns) , [jenis](/docs/id-id/cloud/reference/types) , dan [kode kesalahan](/docs/id-id/cloud/reference/errors).
| 12 |
https://create.roblox.com/docs/id-id/education/educator-onboarding/landing
|
id-id
|
1. [Education](/docs/id-id/education/educator-onboarding/landing)
2. /
3. [Ringkasan](/docs/id-id/education/educator-onboarding/landing)
Bahasa Indonesia
Masukan
# Pendidik onboarding
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/education/educator-onboarding/landing).
Kursus ini memperkenalkan Anda ke Roblox, mempersiapkan Anda untuk merasa percaya diri menggunakan Roblox sebagai alat pendidikan.Pelatihan, yang termasuk mengatur akun dan perangkat lunak Roblox di perangkat Anda, akan memakan waktu 30 hingga 45 menit.
### [Objektif pembelajaran](#objektif-pembelajaran)
* Memahami cara menerapkan perangkat lunak dan akun Roblox di kelas
* Identifikasi di mana menemukan sumber daya, seperti materi pembelajaran berbasis standar dan handout.
* Berlatih bermain pengalaman Roblox untuk mempelajari kontrol dasar dan konsep Roblox umum.
Terburu\-buru? Dokumen ini mencakup semua langkah yang diperlukan untuk memulai kelas, seperti pengaturan akun dan software.Ini juga termasuk koleksi sumber daya berguna seperti tautan dukungan teknis.
[Unduh Panduan Mulai Cepat](https://prod.docsiteassets.roblox.com/assets/education/educator-onboarding/Handout_-_Getting_Ready.pdf)
### [Modul seri](#modul-seri)
| Artikel | Deskripsi |
| --- | --- |
| **[Mulai](/docs/id-id/education/educator-onboarding/1-intro-to-roblox)** | Pelajari tentang platform Roblox. |
| **[Bermain di Roblox](/docs/id-id/education/educator-onboarding/2-playing-on-roblox)** | Buat akun Anda dan mainkan pengalaman. |
| **[Buat kelas](/docs/id-id/education/educator-onboarding/3-setting-up-a-roblox-classroom)** | Mencakup pengaturan akun dan software. |
| **[Jalankan kelas](/docs/id-id/education/educator-onboarding/4-running-classrooms)** | Tip dan sumber daya tentang menjalankan kelas yang sukses. |
| **[Langkah berikutnya](/docs/id-id/education/educator-onboarding/5-next-steps)** | Koleksi sumber daya berguna, dokumen, dan panduan. |
[Next](/docs/id-id/education/educator-onboarding/1-intro-to-roblox)
| 13 |
https://create.roblox.com/docs/id-id/production/promotion/content-maturity
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Umum
Bahasa Indonesia
Masukan
# Kematangan konten
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/production/promotion/content-maturity).
Kematangan konten memberikan informasi tentang halaman rincian utama pengalaman tentang jenis konten apa pengalaman itu berisi sehingga pemain dapat membuat keputusan yang tepat tentang apa yang mereka interaksi.Roblox menggunakan informasi ini untuk merekomendasikan pengalaman di halaman [Rumah](https://www.roblox.com/home) dan [Temukan](https://www.roblox.com/discover) berdasarkan kelompok usia masing\-masing pemain dan kebijakan konten regional.
Kematangan konten terdiri dari dua komponen:
* Label kematangan konten \- Menunjukkan tingkat kematangan yang sesuai untuk pengalaman menurut penelitian pengembangan anak dan standar industri.
* Penggambaran konten \- Menunjukkan jenis konten apa yang ada dalam pengalaman, seperti representasi realistis darah atau perdagangan barang berbayar.
Jika pengalaman tidak memiliki informasi maturitas konten yang akurat atau lengkap, Roblox membatasi kemampuan bermain pengalaman di platform untuk pemain yang lebih muda dari 13 tahun.Selain itu, pengalaman tanpa informasi maturitas konten tidak dapat berisi konten [Terbatas](https://en.help.roblox.com/hc/en-us/articles/15869919570708-Roblox-17-Policy-Standards) tanpa risiko moderasi.Untuk alasan ini, Roblox sangat merekomendasikan agar Anda mengisi kuesioner untuk masing\-masing pengalaman Anda sehingga tersedia untuk audiens yang paling sesuai sebagai mungkin.
Deskripsi konten yang menghasilkan label kematangan konten terpisah dari [genre](/docs/id-id/production/publishing/experience-genres) yang mengklasifikasikan pengalaman sesuai dengan gameplay inti mereka.Dalam kasus di mana ada overlap antara genre dan konten atau perilaku dalam pengalaman, jawablah survei Kematangan \& Kesesuaian seakurat mungkin terlepas dari pilihan genre atau penugasan dari Roblox.
Informasi maturitas konten hanya berlaku untuk konten yang Anda buat untuk pengalaman Anda.Ini tidak tidak berlaku untuk konten yang dihasilkan oleh pengguna yang dibawa pemain ke dalam pengalaman Anda, seperti pakaian dan aksesori avatar.
## [Hasilkan label](#hasilkan-label)
Jika akun Roblox Anda berusia setidaknya 30 hari, Anda dapat menghasilkan informasi maturitas konten dengan mengisi Kuesioner Kematangan \& Kesesuaian , yang berisi serangkaian pertanyaan tentang jenis konten yang mungkin ditemui dalam pengalaman Anda, serta seberapa sering terjadi.Jawaban Anda memberi Roblox pemahaman tentang konten di pengalaman Anda dan memastikan bahwa pengalaman tersedia untuk audiens yang tepat.
Jika pengalaman Anda akan memiliki [konten terbatas](https://en.help.roblox.com/hc/articles/15869919570708), pertama\-tama harus menerima label matur terbatas sehingga kontennya dibatasi pada pemain yang setidaknya berusia 17 tahun.Anda tidak boleh menambahkan konten terbatas ke pengalaman Anda sebelum menambahkan informasi maturitas konten.
Saat Anda menyelesaikan kuesioner, dasarkan jawaban Anda pada pemain konten paling matang atau ekstrim yang dapat dihadapi dalam pengalaman Anda .Anda dapat mengambil kembali kuesioner dan menghasilkan label kedewasaan baru kapan saja untuk akurat mencerminkan konten dalam pengalaman Anda.Untuk pengalaman terbatas, Anda tidak dapat mengubah maturity, tetapi Anda dapat memperbarui deskripsi kontennya.
Untuk menghasilkan informasi maturitas konten:
1. (Opsi) Jika Anda ingin pengalaman Anda termasuk konten terbatas, konfirmasikan bahwa Anda setidaknya berusia 17 tahun dengan [memverifikasi akun Anda](/docs/id-id/production/publishing/account-verification) sehingga kuesioner dapat mengajukan pertanyaan untuk menghasilkan label matur terbatas.
2. Navigasikan ke [Dashboard Pencipta](https://create.roblox.com/dashboard/creations) dan klik pada thumbnail pengalaman yang ingin Anda menghasilkan informasi maturitas konten untuk.Halaman ringkasan pengalaman Overview ditampilkan.
3. Dalam navigasi kiri, navigasikan ke bagian Audiensi , lalu pilih Kematangan \& Kesesuaian .
4. Jika Anda belum pernah mengambil survei sebelumnya, baca catatan dan rincian, lalu klik Mulai untuk melanjutkan.Jika Anda sebelumnya telah menyelesaikan kuesioner, halaman Kuesioner Selesai ditampilkan, tetapi Anda dapat mengklik tombol Mulai Ulang untuk memulai dari awal.
5. Jawablah setiap halaman pertanyaan berdasarkan konten dalam pengalaman Anda, lalu klik tombol Simpan dan Lanjutkan .Setelah Anda menjawab setiap pertanyaan, halaman Pratinjau Kuesioner menampilkan semua jawaban Anda, label maturitas, deskripsi konten yang sesuai, dan setiap wilayah di mana pengalaman Anda tidak sesuai dengan jawaban Anda.
Silakan tinjau pengalaman Anda dan konfirmasikan bahwa jawaban Anda akurat mencerminkan konten pengalaman Anda.Jika Anda sengaja melewatkan pengalaman Anda, Anda mungkin berada di bawah konsekuensi moderasi .
6. Jika Anda perlu memodifikasi jawaban sebelumnya, klik tombol Edit , jika tidak, klik tombol Submit untuk segera menerbitkan informasi maturitas konten ke halaman utama pengalaman.Jika pengalaman Anda menerima label kematangan Terbatas, server yang menjalankan pengalaman memulai ulang untuk menghapus semua pemain kecuali mereka yang diverifikasi usia sebagai 17\+, dan Studio menghapus semua pencipta dari sesi kolaborasi aktif [apapun kecuali mereka yang diverifikasi usia sebagai 17\+](/docs/id-id/projects/collaboration).
Selama pengalaman Anda tidak memiliki label maturitas Terbatas, jika Anda percaya bahwa informasi maturitas konten Anda tidak sesuai dengan audiens target Anda, Anda dapat memperbarui konten di pengalaman Anda sehingga pengalaman Anda sesuai dengan audiens target Anda, lalu kirim ulang kuesioner.Untuk mempelajari cara Anda dapat menyesuaikan dinamis konten pengalaman Anda untuk audiens yang berbeda, lihat referensi [PolicyService](/docs/id-id/reference/engine/classes/PolicyService).
Jika Anda menerbitkan pembaruan yang mengubah salah satu jawaban dari kuesioner, Anda harus memperbarui jawaban Anda dan mengirim ulang kuesioner untuk tetap sesuai dengan Standar Komunitas Roblox dan Syarat Penggunaan .
## [Kategori kuesioner](#kategori-kuesioner)
Bagian berikut memberikan panduan tentang menjawab pertanyaan dalam setiap kategori kuesioner Kematangan \& Kesesuaian. Informasi maturitas konten hanya berlaku untuk konten yang Anda buat untuk pengalaman Anda , bukan konten yang dihasilkan oleh pengguna yang dibawa oleh pemain, seperti pakaian avatar atau aksesori.
Setelah Anda mengirimkan kuesioner, pengalaman Anda menerima label matang dengan deskripsi konten sesuai dengan tabel berikut, serta hasil kesesuaian regional.
| Label maturasi | Deskripsi |
| --- | --- |
| Minimal | Dapat berisi kekerasan ringan sesekali dan/atau darah tidak realistis ringan. |
| Lembut | Dapat berisi kekerasan ringan berulang, darah tidak realistis berat, konten berbasis takut ringan, dan/atau humor kasar ringan. |
| Sedang | Dapat berisi kekerasan sedang, darah realistis ringan, konten berbasis ketakutan sedang, humor kasar sedang, dan/atau konten perjudian tak dapat dimainkan. |
| Dibatasi | Dapat berisi kekerasan kuat, darah realistis berat, humor kasar sedang, tema romantis, konten perjudian tak dapat dimainkan, kehadiran alkohol, dan/atau bahasa kuat. |
Untuk tetap sesuai dengan undang\-undang dan peraturan lokal, pengalaman dengan label kematangan Terbatas tidak dapat dimainkan untuk pemain yang membuat akun mereka atau berlokasi di negara atau wilayah tertentu, seperti Korea, Arab Saudi, dan Türkiye (Turki).
Sementara orang tua dapat menggunakan kontrol orang tua untuk menghindari sebagian besar batasan konten sesuai dengan apa yang mereka percaya sesuai untuk anak mereka, Roblox membatasi [pembuatan pengguna bebas bentuk](#free-form-user-creation) dan [pertemuan sosial](#social-hangout) kepada pemain di atas 13\.
### [Kekerasan](#kekerasan)
Pertanyaan 1: Apakah pengalaman ini menggambarkan kekerasan dan/atau konten kekerasan?Kekerasan adalah penggunaan sengaja dari kekuatan fisik atau psikologis terhadap pemain atau karakter non\-bermain (NPC).Jika pengalaman Anda melibatkan kekerasan, termasuk di dalam jenis aset [apa pun](/docs/id-id/projects/assets#asset-types), Anda harus mengungkapkannya di Kuesioner Kematangan \& Kesesuaian.Pertanyaan 2: Seberapa kuat kekerasan?Jika pengalaman Anda mengandung kekerasan, Anda harus menentukan tingkat intensitas maksimum kekerasan sesuai dengan tabel berikut:
| Intensitas kekerasan | Deskripsi |
| --- | --- |
| Lembut | Representasi implisit atau tidak realistis tentang kekerasan, seperti tubuh menghilang saat kesehatan mereka mencapai nol. |
| Sedang | Representasi non\-grafis, realistis terlihat representasi kekerasan dan/atau kematian yang tidak melanggar Standar Komunitas Roblox, seperti representasi realistis dari cedera kehidupan nyata. |
|Dibatasi Ilustrasi grafis dan realistis tentang kekerasan dan/atau kematian yang tidak melanggar Kebijakan Konten Terbatas , seperti pembunuhan/dekapitasi non\-dunia nyata, impalement, penggantungan, pemotongan, mutilasi, terputus/terputus bagian tubuh, kehadiran organ, maiming, disfigurasi, dan pembakaran listrik. Pengalaman dengan kekerasan kuat hanya tersedia untuk pemain yang terverifikasi yang berusia setidaknya 17 tahun.
|
Jika Anda menyiratkan kekerasan di mana saja dalam pengalaman Anda, seperti kekerasan yang terjadi di luar layar yang dapat didengar pemain tetapi tidak dapat dilihat, pengalaman Anda secara otomatis memenuhi kriteria ringan.
Jika Anda menunjukkan secara visual kekerasan, kriteria untuk memenuhi kekerasan ringan, sedang, atau kuat tergantung pada konsekuensi kekerasan dari kekerasan.Sebagai contoh, jika konsekuensi kekerasan tidak realistis, pengalaman Anda memenuhi kriteria ringan, tetapi jika ada momen di mana konsekuensi kekerasan realistis, pengalaman Anda memenuhi kriteria sedang atau kuat, bahkan jika kekerasan realistis hanya terjadi sekali.
Roblox tidak mengizinkan konten yang berisi kekerasan ekstrim atau penyalahgunaan fisik atau psikologis serius.Ini termasuk penyalahgunaan dan penyiksaan hewan, representasi realistis dari darah ekstrim, atau representasi, dukungan, atau glorifikasi kejahatan perang atau pelanggaran hak asasi manusia, termasuk penyiksaan.Untuk informasi lebih lanjut, lihat Standar Komunitas Roblox dan Kebijakan Konten Terbatas .
Pertanyaan 3: Seberapa sering kekerasan itu terjadi?Setelah Anda menentukan intensitasnya, Anda juga harus menentukan seberapa sering kekerasan terjadi dalam pengalaman Anda menurut tabel berikut.Perhatikan bahwa bahkan bagian kecil dari pengalaman Anda berisi kekerasan berulang, memenuhi kriteria Berulang.
| Frekuensi kekerasan | Deskripsi |
| --- | --- |
| Terjadwal | Kekerasan terjadi jarang atau sesekali, seperti pada beberapa momen kunci pengalaman. |
| Diulang | Kekerasan terjadi sering, atau terjadi jarang, tetapi ketika terjadi, banyak peristiwa kekerasan terjadi dalam urutan cepat. |
### [Darah](#darah)
Pertanyaan 1: Apakah pengalaman ini menggambarkan darah?Darah adalah cairan merah yang mengalir melalui tubuh manusia dan hewan yang penting untuk kehidupan.Jika pengalaman Anda termasuk darah, termasuk dalam jenis aset [apa pun](/docs/id-id/projects/assets#asset-types), Anda harus mengungkapkannya dalam Kuesioner Kematangan \& Kesesuaian.Pertanyaan 2: Seberapa realistik darah?Jika pengalaman Anda mengandung darah, Anda harus menentukan realisme darah sesuai tabel berikut:
| Realisme darah | Deskripsi |
| --- | --- |
| Tidak realistis | Darah tampak tidak realistis, seperti dipikselkan atau memiliki warna atau bentuk yang berbeda. |
| Realistis | Darah tampak realistis, seperti memiliki warna, bentuk, dan properti percikan yang sama dengan darah di dunia nyata. |
Pertanyaan 3 untuk darah yang tidak realistis: Apakah representasi darah tidak sering dan/atau sesaat?Jika Anda menjawab tidak realistis untuk pertanyaan 2, Anda juga harus menentukan seberapa sering darah tidak realistis terjadi dalam pengalaman Anda sesuai tabel berikut:
| Frekuensi darah yang tidak realistis | Deskripsi |
| --- | --- |
| Tidak | Darah tidak realistis hanya terjadi kadang\-kadang, seperti percikan darah kuning selama beberapa detik. |
| No | Darah yang tidak realistis hanya terjadi sering, seperti pertempuran darah berulang atau dengan gambaran yang bertahan lama. |
Pertanyaan 3 untuk darah realistis: Tingkat darah dan/atau darah apa yang digambarkan?Jika Anda menjawab realistis untuk pertanyaan 2, Anda juga harus menentukan tingkat intensitas maksimum darah sesuai dengan tabel berikut.Perhatikan bahwa jika Anda menggambarkan darah realistis di mana saja dalam pengalaman Anda, seperti tumpahan darah dari jarak jauh, pengalaman Anda secara otomatis memenuhi kriteria Ringan.
| Intensitas darah | Deskripsi |
| --- | --- |
| Cahaya | Percikan darah minimal, seperti percikan darah dari jarak jauh. |
| Berat | Pembantaian darah signifikan, seperti kolam darah, menumpahkan darah, dan percikan darah dekat. Pengalaman dengan darah berat dan realistis hanya tersedia untuk pemain yang terverifikasi yang berusia setidaknya 17 tahun. | |
### [Ketakuan](#ketakuan)
Pertanyaan 1: Apakah pengalaman ini termasuk elemen menakutkan yang dapat memicu ketakutan?Konten berdasarkan ketakutan berisi elemen menakutkan atau menakutkan yang memicu ketakutan pada pemain.Jika pengalaman Anda mencakup elemen menakutkan, termasuk dalam jenis aset [apa pun](/docs/id-id/projects/assets#asset-types), Anda harus mengungkapkannya di Kuesioner Kematangan \& Kesesuaian.Pertanyaan 2: Tingkat elemen menakutkan apa yang ada?Jika pengalaman Anda berisi elemen menakutkan, Anda harus menentukan intensitas elemen sesuai dengan tabel berikut:
| Intensitas elemen menakutkan | Deskripsi |
| --- | --- |
| Lembut | Pernapasan keras/berat, menumbukkan jantung, mengaum atau menjerit, NPC yang menakutkan atau menjerit, musik menakutkan, dan/atau gameplay yang membangun kegairahan. |
| Sedang | Karakter dengan mulut bengkok dengan darah realistis, kurangnya daging dengan jaring penghubung yang terlihat realistis, organ, dan/atau pembuluh darah yang terlihat realistis, luka terbuka realistis, dan/atau mata bocor/darah berdarah dengan darah realistis. |
Contoh Sedang (Tidak Cocok untuk Pembaca Muda)Gambar berikut memenuhi kriteria sedang untuk konten berdasarkan ketakutan.
<img src='https://prod.docsiteassets.roblox.com/assets/promotion/misc/ModerateFear-Blocky.png' alt='' title='' width='100%' height='' />
*Termasuk organ\-organ terlihat, pembuluh darah, dan mata bocor/darah.*
\>
<img src='https://prod.docsiteassets.roblox.com/assets/promotion/misc/ModerateFear-NoFlesh.png' alt='' title='' width='100%' height='' />
*Termasuk darah realistis dan kurangnya daging.*
\>
<img src='https://prod.docsiteassets.roblox.com/assets/promotion/misc/ModerateFear-BloodyEyes.png' alt='' title='' width='100%' height='' />
*Termasuk luka terbuka realistis dan mata bocor/darah.*
\>
Pertanyaan 3: Seberapa sering elemen menakutkan terjadi?Setelah Anda menentukan intensitasnya, Anda juga harus menentukan seberapa sering elemen menakutkan terjadi dalam pengalaman Anda sesuai dengan tabel berikut.Perhatikan bahwa bahkan bagian kecil dari pengalaman Anda berisi elemen menakutkan yang diulang, memenuhi kriteria Terulang.
| Frekuensi elemen menakutkan | Deskripsi |
| --- | --- |
| Terjadwal | Elemen menakutkan terjadi jarang atau sesekali, seperti pada beberapa momen kunci pengalaman. |
| Diulang | Elemen menakutkan entah terjadi sering, atau terjadi jarang, tetapi ketika mereka terjadi, banyak peristiwa kekerasan terjadi dalam urutan cepat. |
### [Humor mentah](#humor-mentah)
Pertanyaan 1: Apakah pengalaman ini menggambarkan, merujuk, atau mendorong humor kasar?Humor kasar adalah jenis humor yang menggambarkan atau merujuk fungsi tubuh, seperti kentut, kentut, muntah, kencing, dan/atau buang air untuk tujuan komedi.Jika pengalaman Anda termasuk humor kasar, termasuk dalam jenis aset [apa pun](/docs/id-id/projects/assets#asset-types), Anda harus mengungkapkannya di Kuesioner Kematangan \& Kesesuaian.Pertanyaan 2: Tingkat humor kasar apa yang ada?Jika pengalaman Anda mengandung humor kasar, Anda harus menentukan intensitas elemen sesuai tabel berikut:
| Tingkat humor kasar | Deskripsi |
| --- | --- |
| Lembut | Menggambarkan dan/atau merujuk penggonggongan, kentut (mis. awan kentut), muntah, dan/atau kentut yang tidak realistis terlihat (mis. kentut kail, kentut emoji). |
| Sedang | Secara realistis menggambarkan dan/atau merujuk pada urin atau kencing, dan/atau adalah pengalaman yang terutama bertema di atau ditetapkan di kamar mandi. |
### [Perjudian](#perjudian)
Pertanyaan 1: Apakah pengalaman ini berisi konten perjudian yang tidak dapat dimainkan?Perjudian adalah praktik pertukaran uang dunia nyata, Robux, atau item nilai dalam pengalaman untuk permainan keberuntungan.Sementara pengalaman tidak dapat berisi konten perjudian yang dapat dimainkan, termasuk perjudian simulasi, Anda dapat menggambarkan konten perjudian yang tidak dapat dimainkan, seperti menunjukkan kasino atau orang bermain kartu yang pemain tidak dapat bertaruh atau mainkan.
Anda tidak perlu melaporkan representasi dari, dan/atau referensi ke, item atau aktivitas yang biasanya terkait dengan perjudian, tetapi bukan permainan kebetulan/keberuntungan, seperti balap kuda, balap mobil, dan chip poker.
### [Pembuatan pengguna bebas bentuk](#pembuatan-pengguna-bebas-bentuk)
Pertanyaan 1: Apakah pengalaman ini termasuk penciptaan pengguna bebas bentuk?Pembuatan pengguna bebas bentuk adalah fitur yang memungkinkan pemain untuk membuat apa pun dalam pengalaman, seperti menulis kata\-kata atau membuat ilustrasi di papan tulis.Meskipun ini berlaku untuk dalam pengalaman, alat menggambar atau membuat bebas bentuk, ini tidak berlaku untuk kreasi dalam pengalaman yang dikumpulkan oleh pemain dengan aset 3D, seperti membangun rumah atau menciptakan pakaian, atau apa pun yang melalui moderasi Roblox sebelum dipublikasikan atau direplikasi.
Jika pengalaman Anda termasuk fitur pembuatan pengguna dalam bentuk bebas, Anda harus mengungkapkannya dalam Kuesioner Kematangan \& Kesesuaian.Pembuatan pengguna bebas bentuk hanya tersedia untuk pemain yang berusia setidaknya 13 tahun.
### [Hangout sosial](#hangout-sosial)
Pertanyaan 1: Apakah tema atau aktivitas utama dari pengalaman ini adalah tempat nongkrong sosial?Hangout sosial adalah pengalaman di mana tema atau aktivitas utama adalah untuk mengobrol atau berinteraksi dengan pemain lain dengan suara atau teks baik sebagai diri mereka sendiri atau sebagai avatar mereka.Sementara ini berlaku untuk permainan vibe, klub, ruang sosialisasi, dan tempat\-tempat pendukung seperti ruangan sedih, tidak berlaku untuk pengalaman roleplay dan/atau simulasi kehidupan di mana pemain mengadopsi berbagai peran seperti guru atau petugas polisi, atau diberi item untuk bermain peran dengan.
Jika pengalaman Anda adalah tempat nongkrong sosial, Anda harus mengungkapkannya dalam Kuesioner Kematangan \& Kesesuaian.Hangout sosial hanya tersedia untuk pemain yang berusia setidaknya 13 tahun.
### [Bahasa kuat](#bahasa-kuat)
Pertanyaan 1: Apakah Anda menggambarkan dan/atau ingin mengizinkan bahasa kuat dalam pengalaman Anda?Bahasa kuat adalah bahasa cabul dan cabul yang tidak digunakan untuk mengganggu, melakukan diskriminasi, memicu kekerasan, atau mengancam orang lain, atau digunakan dalam konteks seksual.Sebagai contoh, konten bahasa kuat bisa menjadi representasi karakter yang tidak dapat dimainkan (NPC) menggunakan kata\-kata cabul seperti "f\-word" yang tidak ditujukan ke karakter atau kelompok orang lain (misalnya "f\* off").
Jika pengalaman Anda mencakup bahasa kuat, Anda harus mengungkapkannya dalam Kuesioner Kematangan \& Kesesuaian.Pengalaman yang termasuk bahasa kuat hanya tersedia untuk pemain yang terverifikasi yang berusia setidaknya 17 tahun.
Jika Anda ingin mengaktifkan bahasa kuat dalam komunikasi pemain selain konten untuk pengalaman Anda 17\+, lihat [Publikkan pengalaman dan tempat](/docs/id-id/production/publishing/publish-experiences-and-places#creator-dashboard).
### [Tema romantis](#tema-romantis)
Pertanyaan 1: Apakah pengalaman ini berisi ekspresi cinta atau kasih non\-seksual yang romantis?Tema romantis adalah ekspresi non\-seksual dari cinta atau kasih.Jika pengalaman Anda mencakup tema romantis, seperti ciuman cepat di mulut, Anda harus mengungkapkannya dalam Surat Pertanyaan Kematangan \& Kesesuaian.Pengalaman yang termasuk tema romantis hanya tersedia untuk pemain yang terverifikasi yang berusia setidaknya 17 tahun.
### [Alcohol](#alcohol)
Pertanyaan 1: Apakah pengalaman ini menggambarkan, merujuk, atau termasuk penggunaan alkohol?Alkohol adalah minuman dewasa yang memabukkan.Jika pengalaman Anda termasuk, menggambarkan, atau merujuk alkohol, atau menggambarkan bisnis dan lokasi dewasa yang menyediakan atau menjual alkohol, seperti karakter minum alkohol di bar, Anda harus mengungkapkannya dalam Surat Pertanyaan Kematangan \& Kesesuaian.Pengalaman yang menggambarkan alkohol hanya tersedia untuk pemain terverifikasi yang berusia setidaknya 17 tahun.
### [Item acak berbayar](#item-acak-berbayar)
Pertanyaan 1: Apakah pengalaman ini berisi item acak berbayar?Item acak berbayar adalah item virtual yang dapat dibeli pemain dengan Robux atau mata uang lainnya.Jika pengalaman Anda mencakup item acak berbayar, seperti koin yang dapat dibeli dengan Robux untuk nanti ditukarkan untuk item virtual acak, Anda harus mengungkapkannya dalam Kuesioner Kematangan \& Kesesuaian.
Anda tidak perlu melaporkan item virtual yang Anda berikan sebagai imbalan pemain menyelesaikan tindakan yang tidak melibatkan pembayaran Robux atau mata uang lainnya.Pertanyaan 2: Apakah pengalaman ini menghormati API kebijakan ArePaidRandomItemsRestricted?Jika pengalaman Anda berisi item acak berbayar, disarankan untuk mengambil tindakan pencegahan wajib untuk melindungi pemain di wilayah tertentu yang tidak mengizinkan item acak berbayar sehingga mereka masih dapat mengakses pengalaman Anda.Untuk memeriksa kapan perlindungan ini diperlukan, gunakan [PolicyService.GetPolicyInfoForPlayerAsync](/docs/id-id/reference/engine/classes/PolicyService#GetPolicyInfoForPlayerAsync) untuk mengembalikan kamus nilai yang menentukan apakah aspek tertentu dari pengalaman perlu diubah untuk pemain unik itu.
Satu entri dalam informasi kebijakan adalah ArePaidRandomItemsRestricted , boolean yang mewakili apakah pemain memenuhi syarat untuk membayar barang acak.Item acak dapat tetap dapat dibeli jika ArePaidRandomItemsRestricted kembali palsu, tetapi jika ArePaidRandomItemsRestricted kembali benar, termasuk logika tambahan untuk disembunyikan, diganti, atau memblokir pembelian item acak untuk pemain tersebut sehingga pengalaman Anda tersedia untuk audiens terbesar mungkin.
### [Perdagangan barang berbayar](#perdagangan-barang-berbayar)
Pertanyaan 1: Apakah pengalaman ini mengandung kemampuan bagi pengguna untuk memperdagangkan barang yang mereka bayar?Perdagangan barang berbayar adalah kemampuan bagi pemain untuk membeli item virtual yang kemudian dapat mereka perdagangkan dengan pemain lain.Jika pengalaman Anda termasuk perdagangan item berbayar, seperti pasar untuk menukar item Terbatas, Anda harus mengungkapkannya dalam Surat Pertanyaan Kematangan \& Kesesuaian.Pertanyaan 2: Apakah pengalaman ini menghormati API kebijakan IsPaidItemTradingAllowed?Jika pengalaman Anda berisi perdagangan barang berbayar, disarankan untuk mengambil tindakan pencegahan wajib untuk melindungi pemain di wilayah tertentu yang tidak mengizinkan perdagangan barang berbayar sehingga mereka masih dapat mengakses pengalaman Anda.Untuk memeriksa kapan perlindungan ini diperlukan, gunakan [PolicyService.GetPolicyInfoForPlayerAsync](/docs/id-id/reference/engine/classes/PolicyService#GetPolicyInfoForPlayerAsync) untuk mengembalikan kamus nilai yang menentukan apakah aspek tertentu dari pengalaman perlu diubah untuk pemain unik itu.
Satu entri dalam informasi kebijakan adalah IsPaidItemTradingAllowed , boolean yang mewakili apakah pemain memenuhi syarat untuk memperdagangkan barang berbayar.Item berbayar dapat tetap dapat diperdagangkan jika IsPaidItemTradingAllowed kembali benar, tetapi jika IsPaidItemTradingAllowed kembali salah, termasuk logika tambahan untuk disembunyikan, diganti, atau memblokir perdagangan item berbayar bagi pemain tersebut sehingga pengalaman Anda tersedia untuk audiens terbesar mungkin.
## [Moderasi kematangan konten](#moderasi-kematangan-konten)
Roblox bergantung pada informasi yang Anda berikan di Kuesioner Kematangan \& Kesesuaian untuk menghasilkan informasi maturitas konten yang akurat, sehingga tim Moderasi dapat memeriksa maturitas konten Anda untuk memastikan keakuratannya berdasarkan konten pengalaman Anda.Setiap kali Roblox menemukan ketidakcocokan antara submit Anda dan konten dalam pengalaman Anda, tindakan berikut terjadi:
* Anda menerima pemberitahuan moderasi melalui pesan pribadi di Roblox.
* Halaman Kuesioner Kematangan \& Kesesuaian pada [Dashboard Pencipta](https://create.roblox.com/dashboard/creations) diperbarui untuk memberikan umpan balik moderator dan panduan tentang cara menghasilkan informasi maturitas konten yang akurat.
* Roblox menyediakan tindakan moderasi.
+ Jika pengalaman Anda berisi konten terbatas tanpa label kematangan terbatas, pengalaman Anda berada di bawah konsekuensi moderasi.
+ Jika pengalaman Anda berisi konten yang dilarang oleh Standar Komunitas Roblox , Syarat Penggunaan , atau Kebijakan Konten Terbatas , pengalaman Anda berada di bawah konsekuensi moderasi.
+ Jika pengalaman Anda sebaliknya memiliki informasi maturitas konten yang tidak akurat menurut kontennya, Roblox dapat menghapus label maturitas (atau hanya beberapa atau semua deskripsi jika label maturitas dibatasi) dari pengalaman Anda.Jika pengalaman tidak memiliki informasi maturitas konten, Roblox membatasi kemampuan bermain pengalaman di platform untuk pemain yang lebih muda dari 13 tahun.
+ Jika Anda berulang kali memasukkan informasi maturitas konten yang tidak akurat, pengalaman dan/atau akun Anda berada di bawah konsekuensi moderasi .
Jika menerima tindakan moderasi dan percaya Roblox melakukan kesalahan, Anda dapat mengajukan banding keputusan:
1. Navigasikan ke [roblox.com/support](http://roblox.com/support) .
2. Setelah Anda mengkonfirmasi informasi kontak dan jenis perangkat,
1. Atur Jenis kategori bantuan ke Moderasi . Menu dropdown baru ditampilkan.
2. Tetapkan Jenis Subkategori Bantuan ke Saya dibatasi salah untuk konten lain yang saya buat .
3. Di bidang input, jelaskan mengapa tindakan moderasi adalah kesalahan.
3. Klik tombol Lanjutkan untuk mengirim banding Anda.
| 14 |
https://create.roblox.com/docs/id-id/production/publishing/about-GDPR-and-CCPA
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Umum
Bahasa Indonesia
Masukan
# Tentang GDPR dan CCPA
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/production/publishing/about-GDPR-and-CCPA).
Informasi di bawah ini disediakan untuk tujuan informasi umum saja dan bukan nasihat hukum.Jika Anda memiliki pertanyaan tentang informasi ini atau situasi atau hak spesifik Anda, silakan hubungi pengacara.
## [Apa itu GDPR?](#apa-itu-gdpr)
GDPR berarti Peraturan Perlindungan Data Umum .GDPR adalah undang\-undang di Uni Eropa yang berfokus pada perlindungan informasi pribadi semua orang di Uni Eropa dan Area Ekonomi Eropa dengan menjamin hak khusus untuk koleksi, penggunaan, dan berbagi informasi pribadi mereka.Hak\-hak ini meluas di luar batas\-batas wilayah Eropa, sehingga banyak perusahaan atau individu yang mengumpulkan informasi pribadi UE tunduk pada GDPR.
## [Apa itu CCPA?](#apa-itu-ccpa)
CCPA berarti untuk Undang\-Undang Privasi Konsumen California .Undang\-undang ini memberikan hak kepada konsumen yang tinggal di California, AS, termasuk mengetahui informasi apa yang dikumpulkan tentang mereka, meminta bisnis untuk menghapus informasi pribadi tentang konsumen dari konsumen itu, dan tidak melakukan diskriminasi terhadap konsumen jika mereka melakukan hak privasi mereka.
Apa itu informasi pribadi?Kebanyakan orang mengaitkan istilah "informasi pribadi" atau "informasi yang dapat diidentifikasi secara pribadi" (PII) sebagai data seperti nama, alamat email, atau alamat rumah.Namun, GDPR dan CCPA memiliki definisi yang lebih luas untuk informasi pribadi yang juga dapat mencakup informasi yang tidak langsung terhubung ke individu tertentu, seperti ID pengguna atau alamat IP.
Sebagai aturan umum, pengembang harus tidak mengumpulkan lebih banyak informasi pribadi daripada yang disediakan oleh Roblox, misalnya ID pengguna dan nama pengguna untuk pemain mereka.Untuk informasi lebih lanjut, lihat aturan komunitas kami [untuk komunitas](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Rules).
## [Dampak pada pengembang](#dampak-pada-pengembang)
Sebagai pengembang, berikut adalah beberapa cara untuk menghormati hak pemain di bawah GDPR dan CCPA:
* Anda mungkin menerima pesan dari Roblox mengenai permintaan penghapusan informasi pribadi .Roblox mengambil perawatan khusus untuk memverifikasi permintaan ini untuk memastikan bahwa mereka sah, jadi Anda harus hanya mematuhi permintaan dari Roblox .Jika pemain menghubungi Anda terlebih dahulu, silakan minta mereka untuk membuat permintaan di <https://www.roblox.com/support>.
* Selain dari ID pengguna dan nama pengguna, jangan tidak menyimpan bentuk informasi pribadi lain seperti tanggal lahir atau foto pribadi.
* Jika Anda diminta oleh Roblox untuk menghapus informasi pribadi tentang individu yang telah mengeklaim hak mereka di bawah GDPR atau CCPA, Anda mungkin perlu menghapus data tertentu dari penyimpanan data pengalaman Anda .
* Jika Anda sudah menyimpan informasi pribadi lain di luar apa yang Roblox berikan akses ke, hapus dan perbarui pengalaman Anda sehingga tidak menyimpan data itu di masa depan.
| 15 |
https://create.roblox.com/docs/id-id/production/publishing/dmca-guidelines
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Umum
Bahasa Indonesia
Masukan
# Petunjuk DMCA
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/production/publishing/dmca-guidelines).
Informasi di bawah ini disediakan untuk tujuan informasi umum saja dan bukan nasihat hukum.Jika Anda memiliki pertanyaan tentang informasi ini atau situasi atau hak spesifik Anda, silakan hubungi pengacara.
## [Pertanyaan yang sering ditanyakan](#pertanyaan-yang-sering-ditanyakan)
Apa itu hak cipta?Hak cipta adalah perlindungan hukum yang diberikan untuk karya asli dari karya penulisan.Hak cipta melindungi banyak jenis karya kreatif yang berbeda termasuk musik, film, foto, dan buku di antara lain.Hak cipta tidak melindungi fakta atau ide tetapi dapat melindungi ekspresi khusus dari sebuah fakta atau ide.Untuk mempelajari lebih lanjut tentang hak cipta kunjungi [AS.Kantor Hak Milik](https://www.copyright.gov/help/faq/faq-general.html) .
Penting untuk dicatat bahwa Anda masih dapat melanggar hak cipta bahkan jika Anda:
* Tidak memonetarisasi pengalaman Anda.
* Mengakredit pencipta kreator.
* Mengunduh konten dari internet.
* Pikir bahwa penggunaan Anda adalah [penggunaan yang adil](https://copyright.gov/fair-use/).
* Membeli salinan fisik dari konten (DVD, game, dll.).
* Melihat orang lain termasuk konten yang sama dalam pengalaman mereka.
* Menjelaskan bahwa Anda tidak bermaksud melanggar hak cipta siapa pun.
Apa perbedaan antara hak cipta dan merek dagang?Hak cipta hanya satu bentuk hukum kekayaan intelektual.Hak cipta mendorong pencipta untuk membuat karya asli hak cipta.Merek dagang membantu menghindari kebingungan konsumen tentang sumber produk atau layanan dengan melindungi nama merek, logo, atau simbol lain yang membedakan barang atau layanan dari satu pihak dari yang lain.
Apa itu DMCA?Undang\-undang Hak Milenium Digital ("DMCA") memungkinkan pemilik hak cipta atau agen mereka untuk memberi tahu Roblox tentang materi yang mereka yakini melanggar hak cipta mereka dan meminta Roblox untuk menghapusnya.Untuk mematuhi persyaratan DMCA, Roblox harus merespon dengan cepat ke pemberitahuan DMCA yang valid.Roblox juga harus mengadopsi dan secara wajar menerapkan kebijakan yang memberikan penghentian dalam situasi yang tepat pada pengguna yang melanggar hak cipta berulang kali.
* Bagaimana saya dapat mengajukan klaim DMCA?Jika Anda adalah pemilik hak cipta atau agen pemilik hak cipta dan percaya bahwa konten apa pun di Roblox melanggar hak cipta Anda, Anda dapat mengirim pemberitahuan sesuai dengan DMCA dengan menghubungi Agen Hak Milik kami di [copyright\_agent@roblox.com](/docs/id-id/mailto%3Acopyright_agent%40roblox.com), atau Hukum, Perusahaan Roblox, 970 Park Place, Suite 100, San Mateo, CA 94403\.Anda juga dapat menghubungi kami melalui telepon di (888\) 858\-2569\.
* Informasi apa yang harus saya berikan saat mengajukan klaim DMCA?
+ Tanda tangan elektronik atau fisik dari orang yang berwenang bertindak atas nama pemilik hak cipta atau hak lain yang dilanggar.
+ Deskripsi pekerjaan yang dilindungi hak cipta atau hak kekayaan intelektual lain yang menurut Anda telah dilanggar.
+ Deskripsi materi yang menurut Anda melanggar dan di mana itu berada.
+ Alamat Anda, nomor telepon, dan alamat email.
+ Sebuah pernyataan oleh Anda bahwa Anda memiliki keyakinan yang baik bahwa penggunaan materi tersebut tidak diizinkan oleh pemilik hak cipta, agennya, atau hukum.
+ Sebuah pernyataan oleh Anda bahwa informasi di atas dalam pemberitahuan Anda akurat dan bahwa, di bawah hukuman perjamuan, Anda adalah pemilik hak cipta atau kekayaan intelektual atau berwenang untuk bertindak atas nama pemilik hak cipta atau kekayaan intelektual.
* Kapan saya bisa mengharapkan jawaban atas klaim DMCA saya?Jika pemberitahuan Anda sesuai dengan DMCA, kami akan bertindak cepat untuk menghapus konten yang diduga melanggar, dan dalam beberapa kesituasi kami akan bertindak untuk segera menghubungi Anda untuk memperbaiki kekurangan dalam pemberitahuan.
* Apakah pihak lain akan menerima informasi pribadi saya saat mereka menerima klaim?Dalam beberapa kes, kami akan berbagi nama korporasi atau nama pengguna individu yang mengajukan klaim.
Apa yang terjadi jika saya menerima pemberitahuan penghapusan DMCA terhadap sesuatu yang saya posting di Roblox?Jika Anda percaya bahwa konten Anda di Roblox telah dihapus karena kesalahan atau identifikasi yang salah (misalnya, Anda memiliki otorisasi untuk menggunakan konten yang dihapus, atau penggunaan yang adil berlaku) Anda dapat membantah pemberitahuan penghapusan dengan mengirimkan pernyataan balasan DMCA.
* Bagaimana saya tahu apakah saya menerima pemberitahuan penghapusan DMCA?Di antara hal\-hal lain, Roblox akan mengeluarkan peringatan di akun Anda untuk memberi tahu Anda tentang klaim DMCA.Kami juga akan memberi tahu Anda melalui email (jika alamat email terkait dengan akun Anda) dan melalui sistem pesan Roblox untuk memberi Anda lebih banyak rincian.
Pesan akan dikirim ke email yang terkait dengan akun Roblox Anda.
Jika Anda tidak memiliki email yang terhubung dengan akun Roblox Anda, Anda hanya akan menerima pesan Roblox.Kami sangat mendorong Anda untuk menautkan email ke akun Roblox Anda sebagai tindakan pencegahan keamanan dan untuk menerima email penting dari kami.
* Bagaimana jika klaim DMCA dibuat terhadap pengalaman saya?Haruskah klaim yang valid dibuat terhadap pengalaman Anda, pengalaman Anda akan dihapus atau akses ke sana akan dinonaktifkan.
Jika pengalaman Anda dihapus karena pemberitahuan DMCA, umumnya kami tidak dalam posisi untuk membuka kembali pengalaman tanpa izin pemilik hak cipta, kecuali jika Anda telah mengajukan kontra\-pernyataan di bawah DMCA.Roblox tidak dalam posisi untuk mendapatkan izin seperti itu atas nama Anda.
Bagaimana saya mengajukan peringatan balasan DMCA?Ketika kami memberi tahu Anda tentang pemberitahuan DMCA, kami juga memberikan instruksi tentang cara mengajukan kontra\-pernyataan, yang dapat dikirim ke agen DMCA kami: [copyright\_agent@roblox.com.Perhatikan](/docs/id-id/mailto%3Acopyright_agent%40roblox.com.Perhatikan) bahwa jika Anda berusia di bawah 13 tahun, seorang orang tua atau perwakilan orang dewasa lainnya harus mengajukan pemberitahuan balasan atas nama Anda.
* Apa yang akan terjadi setelah saya mengirimkan pemberitahuan balasan DMCA?Jika kami menentukan bahwa pemberitahuan balasan Anda valid, kami akan mengirimkannya kepada orang yang mengirim pemberitahuan penghapusan hak cipta.Berdasarkan pemberitahuan balasan yang valid, Roblox umumnya akan mengembalikan konten Anda dalam 10\-14 hari kerja, kecuali kami diberitahu bahwa gugatan diajukan terhadap Anda.
Ketahuilah bahwa mengirimkan pernyataan balasan dapat memiliki konsekuensi serius.Jika orang yang mengirim pemberitahuan penghapusan hak cipta percaya bahwa counter\-notice Anda tidak akurat, atau konten Anda melanggar, mereka dapat mengajukan tuntutan hukum terhadap Anda.Juga, mengirim pemberitahuan balasan palsu dengan sengaja adalah ilegal dan dapat menempatkan Anda dalam tanggung jawab.
Bagaimana saya menemukan konten yang sebelumnya saya unggah?Anda dapat mengidentifikasi konten yang sebelumnya Anda unggah dengan menavigasi ke halaman [Kreasi](https://create.roblox.com/dashboard/creations?activeTab=Model) dan menggunakan tab di bagian atas layar untuk menavigasi melalui berbagai jenis aset yang diunggah ke akun Anda.
Di mana saya dapat menemukan lebih banyak informasi tentang proses DMCA Roblox?Silakan lihat [Ketentuan Penggunaan](https://en.help.roblox.com/hc/en-us/articles/115004647846-Roblox-Terms-of-Use) kami di bawah bagian 6 dari Syarat Pengguna untuk informasi tentang DMCA.
Bagaimana jika saya pikir seseorang telah menyalin materi asli yang saya unggah ke Roblox?Jika Anda percaya bahwa seseorang telah salah menyalin materi asli yang sebelumnya Anda unggah ke Roblox, Anda dapat mengajukan keluhan menggunakan Proses Keluhan Penyalinan Pengguna ke Pengguna Roblox.Keluhan dapat diajukan dengan mengirim email ke [copyright\_agent@roblox.com](/docs/id-id/mailto%3Acopyright_agent%40roblox.com), mengidentifikasi materi yang disalin, pekerjaan asli, dan setiap rincian lain yang relevan.Silakan lihat bagian "Perselisihan Antara Pengguna dan Pencipta atau Antara Pencipta" dari [Ketentuan Penggunaan](https://en.help.roblox.com/hc/en-us/articles/115004647846-Roblox-Terms-of-Use) kami untuk informasi lebih lanjut.
| 16 |
https://create.roblox.com/docs/id-id/ai-data-sharing
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Umum
Bahasa Indonesia
Masukan
# Berbagi data AI
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/ai-data-sharing).
Roblox memiliki serangkaian solusi berbasis AI, termasuk [Asisten Kode](/docs/id-id/studio/script-editor#code-assist) , [Pembangkit Bahan](/docs/id-id/studio/material-generator) , [Asisten](/docs/id-id/assistant/guide) , terjemahan obrolan dalam pengalaman, [Pembangkit Teks](/docs/id-id/studio/texture-generator) , dan [Pengaturan Avatar](/docs/id-id/avatar-setup).Alat\-alat ini membantu Anda dengan cepat menemukan informasi, mempercepat proses penciptaan, dan melengkapi keterampilan yang ada.
Untuk meningkatkan alat ini dan membangun yang baru, Roblox menggunakan data untuk melatih model AI generatifnya.
Ketika Anda mempublikasikan pengalaman di Studio, mengunggah item avatar, atau mengunggah aset berbayar ke [Toko Pencipta](/docs/id-id/production/creator-store) (akan datang), Anda memiliki opsi untuk berbagi data Anda.Pilihan default di antarmuka pengguna didasarkan pada pengaturan di [Hub Pencipta](https://create.roblox.com/).
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Data-Share-Dialog.png' alt='An image of the publish experience dialog showing the data sharing toggle.' title='' width='70%' height='' />* Pengaturan berbagi data adalah mati secara default untuk pengalaman, item avatar, dan aset berbayar yang dipublikasikan sebelum 10 Juli 2024\.
* Pengaturan berbagi data adalah pada default untuk pengalaman, item avatar, dan aset berbayar yang dipublikasikan pada atau setelah 10 Juli 2024\.
Anda dapat mengubah pilihan default Anda kapan saja dan menggantikannya sesuai keinginan setiap kali Anda menerbitkan.
Karena mereka didistribusikan dengan niat orang lain yang menggunakannya, bebas [Toko Pencipta](/docs/id-id/production/creator-store) aset dibagikan secara default, tanpa kemampuan untuk menonaktifkan berbagi.
## [Kelola preferensi berbagi data](#kelola-preferensi-berbagi-data)
Untuk mengatur preferensi berbagi data global Anda:
1. Di [Hub Pencipta](https://create.roblox.com/), klik nama pengguna Anda dan Pengaturan .
2. Pilih Berbagi Data .
3. Aktifkan atau nonaktifkan Membuat data berbagi menjadi opsi default saat mempublikasikan pengalaman .
4. (Opsi) Pilih pengalaman individu, item avatar, dan aset Toko Pencipta berbayar untuk dibagikan atau tidak dibagikan.
## [Bagaimana Roblox menggunakan data](#bagaimana-roblox-menggunakan-data)
Semua data yang dibagikan dengan Roblox hanya untuk tujuan peningkatan AI dan tidak dibagikan dengan pihak ketiga.Data diproses dan disimpan sesuai dengan protokol keamanan yang ketat, tidak berisi informasi pribadi, dibagi menjadi token (potongan kecil) untuk anonimisasi lebih lanjut, dan disimpan hanya selama itu bermanfaat untuk peningkatan model.Roblox secara teratur meninjau dan menghapus data bersama.
Jika Anda berbagi sesuatu dan kemudian berhenti berbaginya, Roblox akan menghapusnya dari dataset pelatihan dalam 30 hari.Setiap model AI yang dilatih menggunakan data Anda akan diperbarui dalam 365 hari.
## [Luau Publik](#luau-publik)
Sebelumnya, Roblox meluncurkan program yang memungkinkan Anda untuk berbagi skrip Anda dengan Roblox, set data Luau publik, atau keduanya.Roblox tidak lagi menggunakan data skrip yang hanya dibagikan dengan Roblox.Sebagai gantinya, Anda sekarang memutuskan apakah Anda ingin berbagi seluruh pengalaman, termasuk skrip mereka.
Set data publik Luau tidak terpengaruh oleh perubahan ini.Anda dapat mengatur preferensi berbagi di Hub Pencipta di tab Luau Umum .Untuk lebih banyak rincian tentang dataset publik, lihat [Memberdayakan pembuatan Luau](https://create.roblox.com/data-collection).
| 17 |
https://create.roblox.com/docs/id-id/production/publishing/account-verification
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Umum
Bahasa Indonesia
Masukan
# Verifikasi akun
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/production/publishing/account-verification).
Verifikasi akun adalah proses menghubungkan identitas Anda di Roblox ke identitas dunia nyata Anda, baik melalui ID pemerintah atau melalui nomor telepon Anda.Ketika Anda memverifikasi akun Anda, Anda dapat mendistribusikan lebih banyak jenis aset dan memaksimalkan kemampuan penemuan mereka di dalam [Toko Pencipta](/docs/id-id/production/creator-store), mendistribusikan aset audio dalam waktu kurang dari 10 detik, memonetarisasi [plugin](/docs/id-id/studio/plugins) Anda, dan mengakses fitur terbatas usia seperti [obrolan suara](/docs/id-id/chat/voice-chat) .
Verifikasi nomor telepon tidak cukup untuk menjual aset berharga di Toko Pencipta.Untuk menjual aset berharga, Anda perlu memverifikasi dengan [ID pemerintah](/docs/id-id/production/publishing/account-verification#verify-through-government-id) dan membuat akun penjual.Untuk informasi lebih lanjut, lihat [Jual di Toko Pencipta](/docs/id-id/production/sell-on-creator-store).
## [Verifikasi melalui ID pemerintah](#verifikasi-melalui-id-pemerintah)
Untuk memverifikasi akun Anda dengan metode ini, Anda harus:
* Berusia setidaknya 13 tahun.
* Memiliki identitas foto yang dikeluarkan oleh pemerintah dengan gambar di atasnya, seperti lisensi pengemudi, paspor, atau izin tempat tinggal.
* Memiliki perangkat seluler dengan kamera yang dapat mengambil foto wajah dan ID Anda.Roblox tidak menyimpan dokumen ID mentah maupun data selfie .Saat Anda memindai ID yang dikeluarkan pemerintah untuk verifikasi, sistem menghasilkan nilai anonim, yang memungkinkan Roblox untuk memverifikasi identitas Anda dengan aman tanpa mempertaruhkan eksposur identitas Anda kepada orang lain.Untuk informasi lebih lanjut tentang proses verifikasi akun, lihat [FAQ Verifikasi ID Usia](https://en.help.roblox.com/hc/en-us/articles/4407276151188).
Untuk memverifikasi akun Anda dengan ID yang dikeluarkan pemerintah:
1. Navigasikan ke [roblox.com](https://www.roblox.com/home).
2. Di sudut kanan atas, klik ikon peralatan untuk menampilkan menu dropdown konteks, lalu pilih Pengaturan .
<img src='https://prod.docsiteassets.roblox.com/assets/publishing/account-verification/Account-Settings.png' alt='Account settings menu on roblox.com' title='' width='720' height='' />
3. Di bagian Pribadi , klik tombol Verifikasi Usia Saya . Dialog Verifikasi Identitas ditampilkan.
<img src='https://prod.docsiteassets.roblox.com/assets/publishing/account-verification/Verify-My-Age.png' alt='' title='' width='780' height='' />
4. Pindai kode QR dengan perangkat seluler Anda, yang meminta Anda untuk memulai proses verifikasi usia melalui layanan verifikasi pihak ketiga.
5. Klik tombol Mulai Sesi . Sebuah popup akan ditampilkan untuk meminta persetujuan Anda untuk mengakses kamera Anda.
6. Klik Memungkinkan .
7. Sebagai tampilan prompt yang berbeda, gunakan telepon Anda untuk mengambil foto ID pemerintah dan wajah Anda.Jika layanan tidak dapat memproses data verifikasi Anda, itu meminta Anda untuk menangkap ulang gambar yang diperlukan; jika tidak, pesan sukses ditampilkan dan tombol Verifikasi Usia Saya berubah menjadi Usia Diverifikasi .
8. (Opsi) Mulai ulang Studio untuk memverifikasi status verifikasi usia baru Anda.
## [Verifikasi melalui nomor telepon](#verifikasi-melalui-nomor-telepon)
Untuk memverifikasi akun Anda dengan metode ini, Anda harus berusia setidaknya 13 tahun dan memiliki nomor telepon yang dapat menerima pesan teks.Anda hanya dapat menggunakan nomor telepon Anda dengan akun Roblox tunggal tunggal .
Untuk memverifikasi akun Anda dengan nomor telepon Anda:
1. Navigasikan ke [roblox.com](https://www.roblox.com/home).
2. Di sudut kanan atas, klik ikon peralatan untuk menampilkan menu dropdown konteks, lalu pilih Pengaturan .
<img src='https://prod.docsiteassets.roblox.com/assets/publishing/account-verification/Account-Settings.png' alt='Account settings menu on roblox.com' title='' width='720' height='' />
3. Di bagian Info Akun , klik tombol Tambahkan Telepon . Dialog Tambahkan Telepon ditampilkan.
<img src='https://prod.docsiteassets.roblox.com/assets/publishing/account-verification/Add-Phone.png' alt='' title='' width='780' height='' />
4. Klik menu dropdown Kode Negara , lalu pilih kode negara yang berlaku.
5. Isi bidang berikut:
* Nomor Telepon — Nomor telepon untuk perangkat seluler pribadi Anda.
* Verifikasi Kata Sandi Akun — Kata sandi passwordaktif Anda.
6. Klik tombol Tambahkan Telepon . Sistem menampilkan kode 6 digit pada telepon Anda, dan dialog Verifikasi Telepon Anda ditampilkan.
<img src='https://prod.docsiteassets.roblox.com/assets/publishing/account-verification/Verify-Phone-Dialog.png' alt='' title='' width='678' height='' />
7. Masukkan kode verifikasi 6 digit, lalu klik tombol Lanjutkan .Setelah beberapa saat, bidang Nomor Telepon berubah untuk menyertakan nomor telepon Anda dan status Terverifikasi .
<img src='https://prod.docsiteassets.roblox.com/assets/publishing/account-verification/Phone-Verified.png' alt='' title='' width='780' height='' />
8. (Opsi) Mulai ulang Studio untuk memverifikasi status verifikasi usia baru Anda.
## [Periksa status verifikasi oleh skrip](#periksa-status-verifikasi-oleh-skrip)
Dalam [Script](/docs/id-id/reference/engine/classes/Script) , metode [Player:IsVerified()](/docs/id-id/reference/engine/classes/Player#IsVerified) memungkinkan Anda untuk memeriksa status verifikasi pengguna yang mengakses pengalaman Anda, memungkinkan Anda untuk membatasi akses ke konten tertentu, antrian peringkat, atau bahkan pengalaman itu sendiri.Karena pengguna yang memverifikasi akun mereka menghubungkan identitas Roblox mereka ke identitas dunia nyata, kemungkinan mereka akan mencurangi, spam, atau berisiko diblokir dari pengalaman Anda sangat kecil, sehingga metode ini sangat berguna untuk pengalaman kompetitif dan berperingkat.
Skrip berikut memeriksa status verifikasi setiap pemain saat mereka bergabung dengan pengalaman.Jika mereka telah memverifikasi akun mereka, konsol mencetak true .
```
---
```
local Players = game:GetService("Players")
local function onPlayerAdded(player)
print(player:IsVerified())
end
for _, player in Players:GetPlayers() do
onPlayerAdded(player)
end
Players.PlayerAdded:Connect(onPlayerAdded)
```
```
| 18 |
https://create.roblox.com/docs/id-id/projects/group-guidelines
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Umum
Bahasa Indonesia
Masukan
# Panduan kelompok
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/group-guidelines).
Jika Anda adalah pemilik satu atau lebih [kelompok](/docs/id-id/projects/groups), baca dengan seksama harapan berikut untuk mengelola kelompok Anda.
## [Aturan Roblox](#aturan-roblox)
Grup Roblox dan semua konten yang diunggah kepada mereka harus mengikuti Standar Komunitas Roblox dan Syarat Penggunaan .Konten yang diunggah ke grup yang terkena Standar Komunitas termasuk, tetapi tidak terbatas pada:
* Aktiva
* Avatar
* Pengalaman
## [Tanggung jawab pemilik](#tanggung-jawab-pemilik)
Pemilik kelompok memainkan peran penting dalam menjaga lingkungan aman dan positif di dalam kelompok mereka.
* Pemilik kelompok harus melakukan upaya yang wajar untuk mengatasi dan mengatasi perilaku berbahaya di komunitas dan kelompok mereka.
* Pemilik kelompok bertanggung jawab untuk menggunakan alat moderasi yang disediakan oleh Roblox seperti [riwayat aktivitas](/docs/id-id/projects/groups#group-activity-history) untuk secara proaktif memastikan lingkungan yang sehat dan konten yang berpotensi melanggar.
## [Pelanggaran dan konsekuensi](#pelanggaran-dan-konsekuensi)
Kelompok yang melanggar Standar Komunitas Roblox mungkin menghadapi tindakan penegakan seperti peringatan, batasan fitur, penguncian sementara, dan — untuk pelanggaran berulang atau parah — penghapusan permanen.Pemilik kelompok dapat [membantah](https://en.help.roblox.com/hc/en-us/articles/360000245263-Appeal-Your-Content-or-Account-Moderation) tindakan penegakan jika mereka percaya bahwa mereka tidak benar.
* Pelanggaran Anggota — Meskipun pemilik kelompok tidak langsung dihukum karena pelanggaran anggota, kegagalan berulang untuk mengatasi pelanggaran dalam kelompok dapat menyebabkan batasan masa depan atas kepemilikan kelompok.Seorang pemilik yang grupnya dihapus secara permanen tidak akan dapat memiliki grup baru selama 90 hari.Beberapa penghapusan permanen akan menyebabkan hilangnya seluruh hak kepemilikan kelompok bagi pemiliknya.
* Pelanggaran Pemilik — Pemilik kelompok yang ditemukan menggunakan kelompok mereka untuk mempromosikan atau memudahkan pelanggaran Standar Komunitas Roblox (melalui mengunggah atau mendorong upload konten yang melanggar) akan menghadapi tindakan penegakan di akun mereka sendiri dan mungkin penghapusan permanen kelompok mereka.
| 19 |
https://create.roblox.com/docs/id-id/marketplace/marketplace-policy
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Marketplace
Bahasa Indonesia
Masukan
# Kebijakan kebijakan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/marketplace/marketplace-policy).
Aksesori dan aset pakaian 3D yang Anda jual di [Pasar](https://www.roblox.com/catalog) , seperti aksesori pakaian, harus mengikuti persyaratan khusus.Beberapa persyaratan mungkin memerlukan konfigurasi tambahan pada perangkat lunak model pihak ketiga, seperti Blender atau Maya.
Jika Anda siap untuk menjual item dan item memenuhi persyaratan di bawah ini, lihat [Publish Marketplace items](/docs/id-id/marketplace/publish-to-marketplace) untuk rincian tentang penerbitan aset.
## [Persyaratan pencipta](#persyaratan-pencipta)
Untuk upload, mempublikasikan, dan memelihara konten yang ada dijual, Roblox memerlukan pengguna dan kelompok untuk memiliki [verifikasi ID](https://en.help.roblox.com/hc/en-us/articles/4407282410644) dan [keanggotaan premium](https://www.roblox.com/premium/membership).Akun Anda yang diverifikasi ID harus berpartisipasi dalam keanggotaan Premium 1000/2200 aktif untuk menjaga item Marketplace Anda dijual setelah diunggah dan dipublikasikan.
Lihat ringkasan berikut dari persyaratan pengguna dan kelompok:
| Pencipta dapat... | | Persyaratan ID/Premium |
| --- | --- | --- |
| Secara individual | Upload konten dari Studio | — Verifikasi ID |
| | Publikasikan konten ke Pasar | — Verifikasi ID— Premium 1000/2200 |
| Tetapkan konten yang ada dijual | — Verifikasi ID— Premium 1000/2200 |
| Sebagai Grup | Upload konten dari Studio | Mengunggah kebutuhan pengguna: — Verifikasi ID— Premium 1000/2200 |
| | Publikasikan konten ke Pasar | Mempublikasikan kebutuhan pengguna: — Verifikasi ID— Pemilik kelompok Premium 1000/2200:— Premium 1000/2200 |
| Tetapkan konten yang ada dijual | Pemilik kelompok membutuhkan:— Premium 1000/2200 |
## [Panduan pembuatan umum](#panduan-pembuatan-umum)
Saat merancang dan menciptakan aset Anda, ikuti panduan ini untuk memastikan bahwa item Anda melewati moderasi dan memungkinkan pengguna Roblox untuk mengekspresikan diri dengan aman dan sopan.Gagal mengikuti panduan ini dapat menyebabkan [moderasi](/docs/id-id/marketplace/moderation) dan penghapusan item.
Apakah Anda pencipta asli dari aset atau tidak, Anda harus memastikan bahwa Anda memiliki hak untuk mengunggah aset dan bahwa item Anda mematuhi panduan program berikut:
* Ikuti Standar Komunitas Roblox [.](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Standards).Sebagai kejadian, jangan membuat item yang politik, agama, berdarah, kekerasan, terkait dengan diri sendiri, terkait dengan narkoba, seksual/pernikahan/kencan, atau item yang kemungkinan akan digunakan untuk jenis role playini.Ini adalah beberapa contoh item yang melanggar Standar Komunitas.
* Jangan gunakan aset yang dibuat oleh Roblox atau merek atau ikonografi resmi [Roblox](https://en.help.roblox.com/hc/en-us/articles/115001708126) sebagai bagian dari item Anda.
* Jangan membuat item yang terlalu mirip dengan item yang ada, seperti item berharga dan terbatas. Ini termasuk skenario seperti:
+ Pencipta yang sudah mempublikasikan item dan mempublikasikan kembali item yang sama sebagai item Terbatas.
+ Pencipta yang mempublikasikan item Terbatas dan kemudian mempublikasikan kembali item Terbatas yang sama.
+ Pencipta yang menyalin item kreatorlain atau item Roblox.
* Hanya menjual item yang Anda memiliki izin untuk dijual.Jika Anda bukan pencipta atau pemilik asli dari IP, Anda harus memiliki izin dari pemilik IP untuk menjual konten mereka atau konten yang terinspirasi.
* Hati\-hati khusus saat menyajikan item di atau dekat mulut atau pinggul avatar.Pastikan untuk sering menguji aset Anda pada berbagai jenis karakter untuk menghindari masalah desain.
* Jangan membuat item yang sengaja mengganggu pengalaman pengguna, seperti:
+ Menghalangi sebagian besar avatar pengguna.
+ Menghalangi UI pengguna dalam pengalaman.
+ Menghalangi avatar pengguna lain atau pandangan dalam pengalaman.
+ Membuat avatar pengguna menghilang (sepenuhnya atau sebagian).
* Jangan membuat item yang bergantung pada masalah atau kesalahan di platform Roblox.
* Jangan termasuk teks berlebihan pada item.
* Jangan mengkategorikan ulang item Anda, seperti daftar aset celana di kategori Shirt. Lihat [Miskategorisasi](#miscategorization) .
## [Panduan aksesori dan pakaian](#panduan-aksesori-dan-pakaian)
Pengiriman aksesori dan pakaian ke Pasar harus mengikuti panduan tambahan, bersama dengan [panduan umum](#general-creation-guidelines) , [Standar Komunitas](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Standards) , dan spesifikasi teknis masing\-masing untuk [aksesori](/docs/id-id/art/accessories/specifications) atau [pakaian](/docs/id-id/art/accessories/clothing-specifications) item.
### [Kategorisasi Lainnya](#kategorisasi-lainnya)
Jangan salah kategorikan item saat Anda mengunggahnya. Kategorisasi yang tepat termasuk hal mengikuti:
* Gaya rambut lengkap (rambut dengan penutup kepala penuh) harus ada di kategori Rambut.
+ Gaya rambut parsial (seperti Bangs dan Braids) dapat berada di kategori Kepala, Wajah, atau Rambut.
+ Rambut wajah harus berada di kategori Wajah.
* Aksesori rambut yang terutama terlihat di atas leher harus berada di Kepala atau Wajah.Aksesori tidak terutama terlihat di atas leher tidak dapat berada dalam kategori ini.
+ Item yang duduk hanya di bahu avatar bisa berada di Bahu.
* Kategori pakaian harus berada dalam kelompok yang tepat dari Atas atau Bawah.
+ Desain yang secara khusus Tops (T\-Shirt, Shirt, Jaket) harus berada di salah satu kategori Tops tersebut.
+ Desain yang secara khusus Bottoms (Shorts, Pants, Skirt) harus berada di salah satu kategori Bottoms tersebut.
* Desain topi (seperti topi bisbol, beanies, topi koboi) harus ada di kategori Kepala.
+ Desain yang menggabungkan item Kepala dengan desain rambut (seperti topi dengan rambut menonjol, mohawk dengan headphone) dapat berada di kategori Kepala atau Rambut.
* Desain yang merupakan komponen anatomi wajah (misalnyahidung, kumis) atau aksesori yang menambahkan anatomi wajah (misalnyaBayangan mata, kemerahan, kerutan) harus berada di kategori Wajah.
* Roblox secara otomatis mendeteksi kostum tubuh, pakaian yang sepenuhnya menutupi tubuh di bawah kepala, dan secara otomatis mengkategorikan mereka setelah upload.
## [Panduan tubuh avatar](#panduan-tubuh-avatar)
Kiriman tubuh avatar ke Pasar harus mengikuti panduan tambahan, bersama dengan [panduan umum](#general-creation-guidelines) , [standar komunitas](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Standards) , dan [spesifikasi teknis avatar](/docs/id-id/art/characters/specifications).
### [Persyaratan bagian tubuh](#persyaratan-bagian-tubuh)
Setiap tubuh hanya dapat mencakup bagian berikut, dan tidak dapat memiliki tambahan appendages:
* Bagian Tubuh
+ 1 lengan kanan, terdiri dari lengan atas, lengan bawah, dan tangan.
+ 1 lengan kiri, terdiri dari lengan atas, lengan bawah, dan tangan.
+ 1 torso, terdiri dari torso atas dan torso lebih rendah.
+ 1 kaki kanan, terdiri dari kaki atas, kaki bawah, dan kaki.
+ 1 kaki kiri, terdiri dari kaki atas, kaki bawah, dan kaki.
* Kepala
+ Kepala (termasuk mata yang dimasak, hidung, telinga, dan mulut, jika berlaku)
- Semua kepala harus termasuk 17 minimum [kontrol FACS](/docs/id-id/art/characters/facial-animation/facs-poses-reference).
- Disarankan untuk menambahkan lebih banyak pose untuk meningkatkan kualitas dan ketepatan animasi wajah.
+ Alis (opsional)
+ Bulu mata (opsional)
Avatar harus mematuhi persyaratan ukuran yang tepat [dan tidak dapat memiliki bagian tubuh yang tidak terlihat atau tidak dirender](/docs/id-id/art/characters/specifications#body-scale).Lihat [Spesifikasi karakter avatar](/docs/id-id/art/characters/specifications) untuk informasi lebih lanjut.
Roblox memoderasi avatar yang tidak mengikuti persyaratan bagian tubuh di bawah [Menyalahgunakan Standar Komunitas Sistem Roblox](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Rules).
### [Lapisan ketertutupan](#lapisan-ketertutupan)
Sebuah *lapisan kesopanan* adalah lapisan pakaian yang menutupi torso bagian atas dan torso bagian bawah avatar.Secara umum, lapisan kesopanan diperlukan jika karakter Anda menyerupai manusia.Lihat yang berikut untuk kebijakan khusus ketika lapisan kesopanan diperlukan:
Lapisan kesopanan diperlukan jika karakter avatar Anda:
* Memiliki tekstur permukaan kulit halus dan datar seperti di daerah selangkangan dan dada.
Lapisan kesopanan adalah opsional jika karakter avatar Anda:
* Mirip dengan hewan .
+ Hewan : Makhluk hidup yang ada di dunia nyata, tidak menyerupai manusia, dan tidak biasanya memakai pakaian.Contoh termasuk: anjing, hiu, serangga, beruang.
* Mirip dengan objek tidak bergerak .
+ Objek tidak bergerak : Objek di dunia nyata yang tidak hidup dan tidak menyerupai manusia atau hewan.Contoh termasuk: barang makanan, batu, buku, rumah.
| Membutuhkan lapisan kesederhanaan | Tidak memerlukan lapisan kesopanan |
| --- | --- |
| | |
Contoh lapisan kesopanan tambahan
| Membutuhkan lapisan kesederhanaan | Tidak memerlukan lapisan kesopanan |
| --- | --- |
| *[GigaChad](https://www.roblox.com/bundles/2836/GigaChad) \>* | *[Superhero Cybernetik](https://www.roblox.com/bundles/808/Cybernetic-Superhero) \>* |
| Scarlett \> | *[Ayam Penggreaser](https://www.roblox.com/bundles/1178/Greaser-Chicken) \>* |
| Claire \> | *[Prajurit Grizzly Perang Beruang Besar](https://www.roblox.com/bundles/370/The-Great-Bear-War-Grizzly-Warrior) \>* |
| *[Octavia The Ivory Spider Girl](https://www.roblox.com/bundles/473/Octavia-The-Ivory-Spider-Girl) \>* | *[Menakut\-nakuti](https://www.roblox.com/bundles/6506/Scarecrow) \>* |
| | *[Warna Naga Kustom](https://www.roblox.com/bundles/7735/Custom-Dragon-Colour) \>* |
| | *[Labu Hidup](https://www.roblox.com/bundles/8734/Living-Pumpkin) \>* |
| | *[Kasual Bisnis Telamons](https://www.roblox.com/bundles/210/Telamons-Business-Casual) \>* |
| | *[Beruang Kutub](https://www.roblox.com/bundles/195/Polar-Bear) \>* |
| | *[Boneka Beruang](https://www.roblox.com/bundles/2094/Teddy-Bear) \>* |
| | Kebingungan \> |
| | *[Gang O' Fries](https://www.roblox.com/bundles/671/Gang-O-Fries) \>* |
| | Tuan Toilet \> |
| | *[Kerangka](https://www.roblox.com/bundles/295/Skeleton) \>* |
| | *[Sahabat Bercakar](https://www.roblox.com/bundles/593/Clawed-Companion) \>* |
Untuk semua lapisan kesopanan, berlaku hal berikut:
* Semua lapisan kesopanan harus benar\-benar tidak transparan.Meskipun mereka dapat menyertakan sorotan artistik, bayangan, atau tekstur, lapisan kesopanan yang murni atau parsial tidak diperbolehkan.
* Lapisan kesopanan harus berwarna berbeda dari warna kulit avatar.
* Lapisan kesopanan dirancang untuk menjadi seksual menyarankan, seperti pakaian dalam, tidak diperbolehkan.
* Kedua lapisan kesopanan torso atas dan bawah diperlukan jika karakter avatar Anda menyerupai di bawah umur.
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Modesty-Layer-Variations.png' alt='' title='' width='60%' height='' />
*Contoh lapisan kesopanan yang tepat*
Roblox memoderasi avatar yang tidak mengikuti persyaratan lapisan kesopanan di bawah [Standar Komunitas Konten Romantis dan Seksual](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Rules).
#### [Torso bawah](#torso-bawah)
Lapisan kesoparan tubuh bagian bawah harus memberikan penutupan penuh dari pinggul avatar ke bagian bawah selangkangan dan paha.Lapisan kesoparan tubuh bagian bawah dapat mencakup gaya pakaian seperti celana dalam, boxer, atau celana pendek laki\-laki yang sepenuhnya menutupi paha.
#### [Torso bagian atas](#torso-bagian-atas)
Anda harus menambahkan lapisan kesopanan bagian atas tubuh jika avatar Anda menggunakan tekstur kulit di dada di mana payudara menonjol dari dada dan memiliki bentuk bulat atau panjang.Lapisan kesoparan tubuh bagian atas tidak diperlukan untuk karakter dengan pectoral berbentuk datar dan berbentuk otot.
Untuk lapisan kesopanan bagian tubuh atas, berlaku hal berikut:
* Untuk karakter yang mirip dengan anak\-anak, lapisan kesopanan torso bagian atas harus memberikan penutupan penuh dari seluruh area payudara dan perut, seperti tank top.
* Untuk karakter yang tidak menyerupai anak\-anak, lapisan kesopanan torso bagian atas harus memberikan penutupan penuh seluruh area payudara.
+ Penutupan dapat digambarkan menggunakan garis tetapi harus sepenuhnya ditutupi oleh lapisan kesopanan.
+ Cakupan penuh dari belakang tidak diperlukan, tetapi harus jelas bahwa karakter avatar tidak telanjang jika dilihat dari kembali.
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Modesty-Layer-Upper-Torso-Back.png' alt='' title='' width='20%' height='' />
*Layer torso bagian atas harus terlihat jelas dari belakang*
Lapisan kesopanan torso bagian atas dapat mencakup bra tanpa strap, bra racerback, bra balconette, top tabung, crop top, atau top bandeau.
### [Usia yang tepat](#usia-yang-tepat)
Tubuh avatar tidak boleh bersifat seksual menggoda, atau menggambarkan atau menyarankan ketelanjangan di area genital. Ini termasuk:
* Setiap representasi rambut pubik yang terbuka, organ seksual, atau puting
* Setiap representasi dari genitalia, paha atau dada, atau puting melalui atau di sekitar [lapisan kesopanan](#modesty-layers)
* Penekanan atau bayangan berlebihan pada payudara, panggul, atau paha
* Avatar di mana, karena ukuran berlebihan, titik fokus tubuh ada di payudara, panggul, atau paha
Roblox memoderasi avatar yang tidak mengikuti persyaratan lapisan kesopanan di bawah [Standar Komunitas Konten Romantis dan Seksual](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Rules).
### [Aksesori dan pakaian](#aksesori-dan-pakaian)
Tubuh avatar tidak dapat mencakup aksesori atau pakaian.Aksesori adalah item yang dapat Anda temukan secara terpisah di Pasar yang bukan bagian dari persyaratan bagian tubuh, seperti ekornya yang dapat dilengkapi, sayap, ekstremitas tambahan, kacamata, pakaian, [tato](#tattoos) , dan [makeup](#makeup) .Anda harus mengunggah dan menjual item ini secara terpisah.Kepala bisa termasuk rambut, bulu mata, dan alis, tetapi ini juga harus menjadi item terpisah.
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Acc-Antenna.png' alt='' title='' width='100%' height='' />
*Antena adalah contoh aksesori yang dapat Anda temukan di Pasar dan harus dijual secara terpisah.*
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Acc-Robot-Arms.png' alt='' title='' width='100%' height='' />
*Tentakel robot adalah contoh aksesori yang dapat Anda temukan di Pasar dan harus dijual secara terpisah.*
Contoh aksesori tambahan
| Wings |
| --- |
| Horns |
| Antlers |
| Tails |
| Bulu Ekor |
| [Kacamata Hipster](https://www.roblox.com/catalog/125369932/Hipster-Glasses) \> |
| [Kacamata](https://www.roblox.com/catalog/42847660/Epic-Sunglasses) \> |
| [Janggut](https://www.roblox.com/catalog/13209067084/Whiskers) \> |
Berikut adalah contoh versi yang ditolak dan diterima dari aset yang sama:
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Acc-Demon-Horns-A.png' alt='' title='' width='100%' height='' />
*Tubuh ditolak untuk aksesori (tanduk).*
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Acc-Demon-Horns-B.png' alt='' title='' width='100%' height='' />
*[Demon3](https://www.roblox.com/bundles/2485/Demon3) disetujui setelah menghapus aksesori saat uploadtubuh.*
Roblox memoderasi avatar dengan aksesori atau pakaian di bawah [Menggunakan Standar Komunitas Sistem Roblox dengan Tidak Benar](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Rules).
#### [Tato](#tato)
Tato adalah gambar, pola, atau bentuk yang berbeda dari tekstur tubuh dan berbeda warnanya dari bagian tubuh lainnya, Anda harus mengunggah dan menjual tato secara terpisah.Avatar dapat memiliki tekstur, tetapi tidak tato.Tekstur adalah pola berulang yang terlihat seperti objek nyata/fisik dan mencakup setidaknya 50% avatar.Contoh tekstur termasuk: skala, bulu, batu, dan bulu.
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Acc-Tattoos.png' alt='' title='' width='100%' height='' />
*Tanda tato di lengan atas*
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Acc-Skin-Example.png' alt='' title='' width='100%' height='' />
*Tekstur yang membentuk kulit buaya alami*
Berikut adalah contoh versi yang ditolak dan diterima dari aset yang sama:
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Tattoo-Samy-A.png' alt='' title='' width='100%' height='' />
*Tubuh ditolak untuk tato (wajah di leher).*
<img src='https://prod.docsiteassets.roblox.com/assets/art/avatar/Tattoo-Samy-B.png' alt='' title='' width='100%' height='' />
*[Samy the Cobra](https://www.roblox.com/bundles/6699/Samy-The-Cobra) disetujui setelah menghapus tato di tubuh.Perhatikan bahwa avatar ini tidak memerlukan lapisan kesopanan karena tidak memiliki tekstur kulit di area paha.*
#### [Makeup](#makeup)
Kepala avatar dapat menggunakan bayangan dan bayangan untuk menunjukkan dimensi dan definisi.Ini termasuk pewarnaan kelopak mata dalam nada yang mirip dengan warna kulit, bibir berwarna tunggal, eyeliner, bulu mata, dan alis, atau pipi yang dipercantik untuk terlihat berkilau, merah muda, sehat, atau hangat.
Kepala avatar Anda tidak dapat mencakup warna tambahan, penyorotan, atau kontur yang tidak hanya digunakan untuk menunjukkan dimensi dan definisi wajah.Anda harus mengunggah dan menjual fitur ini secara terpisah.Ini termasuk lukisan wajah, bulu mata berwarna multi, eyeliner, dan bibir, dan bayangan mata yang melampaui penghalusan dan tidak terkait dengan warna kulit bagian tubuh lainnya.
| Bayangan wajah dan detail diperbolehkan | Lukisan wajah dan fitur multi\-warna tidak diperbolehkan |
| --- | --- |
| | |
| | |
| | |
### [Ton kulit yang dapat disesuaikan](#ton-kulit-yang-dapat-disesuaikan)
Roblox merekomendasikan termasuk warna kulit yang dapat disesuaikan, atau mutabilitas warna kulit, untuk avatar yang mirip dengan manusia.Mutabilitas warna kulit opsional.Demikian pula, untuk avatar yang dibuat melalui kemitraan merek formal, ketidakstabilan warna kulit opsional.Untuk informasi lebih lanjut tentang membuat teksktur kulit yang dapat disesuaikan, lihat [Kulit Kustom](/docs/id-id/art/characters/specifications#custom-skin-tone).
| 20 |
https://create.roblox.com/docs/id-id/marketplace/intellectual-property
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Marketplace
Bahasa Indonesia
Masukan
# Kekayaan intelektual
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/marketplace/intellectual-property).
Informasi di bawah ini disediakan untuk tujuan informasi umum saja dan bukan nasihat hukum.Jika Anda memiliki pertanyaan tentang informasi ini atau situasi atau hak spesifik Anda, silakan hubungi pengacara.
Kekayaan intelektual (IP) merujuk pada kreasi pikiran, seperti penemuan; karya sastra dan seni; desain; dan simbol, nama, dan gambar yang digunakan dalam perdagangan.Hak cipta adalah perlindungan hukum untuk karya asli dari penulisan.Hak cipta melindungi banyak jenis karya kreatif yang berbeda termasuk musik, film, foto, buku, dan barang virtual di antara lain.
Biasanya ketika Anda membuat karya asli, hal\-hal yang unik tentangnya \- properti intelektual Anda \- secara otomatis mendapat perlindungan hak cipta legal segera setelah Anda membuatnya.Hanya aspek unik dan inventif yang dapat dilindungi oleh hak cipta sehingga semakin asli dan kreatif desain Anda, semakin banyak elemen desainnya dilindungi oleh hak cipta .Mempublikasikan desain di Roblox yang Anda temukan di tempat lain tidak harus memberi Anda kepemilikan IP untuk desain itu secara khusus di Roblox , yang berarti bahwa Anda mungkin tidak dapat mencegah pengguna Roblox lainnya juga membuat desain itu.
Sebagai contoh, pengguna yang membuat topi bisbol virtual di Roblox tidak akan dapat meminta penghapusan topi bisbol yang sama sekali berbeda, seperti yang ditunjukkan di bawah ini:
<img src='https://prod.docsiteassets.roblox.com/assets/art/Cap-A.png' alt='' title='' width='100%' height='' />
<img src='https://prod.docsiteassets.roblox.com/assets/art/Cap-B.png' alt='' title='' width='100%' height='' />
<img src='https://prod.docsiteassets.roblox.com/assets/art/Cap-C.png' alt='' title='' width='100%' height='' />
<img src='https://prod.docsiteassets.roblox.com/assets/art/Cap-D.png' alt='' title='' width='100%' height='' />
Contoh lain di mana Anda mungkin tidak memiliki kepemilikan IP:
* Jika Anda melihat topi yang menarik di dunia nyata atau di platform lain dan ingin membuat replica virtual dari topi itu di Roblox, Anda masih mungkin memerlukan izin dari pencipta asli topi tersebut.
* Jika Anda memberikan kredit kepada pemilik hak cipta, Anda tidak secara otomatis memiliki hak untuk menggunakan karya berhak cipta mereka.
* Jika Anda ingin membuat topi di Roblox terinspirasi oleh gaya topi yang terkenal, seperti topi atas, Anda mungkin tidak dapat menghentikan pengguna lain untuk mengunggah topi serupa.
## [Lindungi IP Anda sendiri](#lindungi-ip-anda-sendiri)
Untuk melindungi IP Anda, penting agar kreasi Anda unik.Sebagai contoh, penciptaan di bawah ini mengambil konsep yang sudah teruji (helm Trojan) dan menambahkan rincian rumit yang membuat desain menjadi ekspresi asli dari ide, seperti bentuk dan orientasi aksesori emas dan bentuk pembuka wajah.
<img src='https://prod.docsiteassets.roblox.com/assets/art/Helmet-A.png' alt='' title='' width='250px' height='' />
*Helm Trojan dengan elemen rincian desain yang mungkin dilindungi hak cipta karena sifat uniknya.*
Ketika pencipta melihat orang lain menggunakan elemen desain asli tertentu dalam desain mereka, seperti contoh di bawah ini, mereka dapat meminta penghapusan item tersebut.
<img src='https://prod.docsiteassets.roblox.com/assets/art/Helmet-B.png' alt='' title='' width='250px' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/art/Helmet-C.png' alt='' title='' width='250px' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/art/Helmet-D.png' alt='' title='' width='250px' height='' />
*Berpotensi melanggar helm Trojan menggunakan elemen desain unik dari asli.*
Tetapi hanya karena pencipta asli dapat meminta penghapusan ketiga helm Trojan tersebut tidak berarti bahwa mereka dapat menghapus *semua* helm Trojan dari platform.Sebagai contoh, helm di bawah ini kemungkinan tidak melanggar karena tidak termasuk elemen unik kreator:
<img src='https://prod.docsiteassets.roblox.com/assets/art/Helmet-A.png' alt='' title='' width='250px' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/art/Helmet-E.png' alt='' title='' width='250px' height='' />
*Secara signifikan membedakan helm Trojan berbagi elemen desain unik dari asli, mengurangi kemungkinan akan dihapus karena pelanggaran IP.*
Cara lain untuk memperkuat perlindungan IP Anda adalah mengintegrasikan merek dagang unik Anda ke dalam barang\-barang Anda.Ini bisa menjadi cara yang membantu untuk membangun merek Anda sendiri secara native di Roblox dan secara visual membedakan kreasi Anda dari orang lain.
Untuk melindungi kreativitas orang lain, Roblox [Ketentuan Penggunaan](https://www.roblox.com/catalog/10546552/Trojan-Infantry-Helmet) menyatakan bahwa setiap konten yang Anda buat harus menghormati hak kekayaan intelektual orang lain \- baik di platform kami maupun di luar platform kami .
* Ini berarti Anda tidak boleh mengunggah konten yang tidak Anda miliki atau tidak mendapatkan izin pemilik untuk digunakan.
* Melanggar hak intelektual seseorang bukan hanya pelanggaran Syarat Penggunaan Roblox, tetapi juga pelanggaran hukum.
## [Roblox melindungi IP Anda](#roblox-melindungi-ip-anda)
Roblox mematuhi Undang\-Undang Hak Milenium Digital (DMCA) dan memiliki proses yang ditunjuk untuk menerima dan menangani laporan penghapusan hak cipta dari pemilik karya asli.
* Roblox harus mengadopsi dan secara wajar menerapkan kebijakan yang memberikan penghentian dalam situasi yang tepat pada pengguna yang melanggar hak cipta berulang kali.
* Roblox menyelidiki setiap laporan dan mengambil actionyang tepat, yang dapat termasuk menghapus atau menonaktifkan konten yang melanggar, dan mengakhiri akun pengguna yang telah berulang kali melanggar IP orang lain secara permanen.
* Jika pengajuan sesuai dengan persyaratan hukum dan item pelanggar dihapus, pencipta pelanggar akan kehilangan biaya [per unit](/docs/id-id/marketplace/marketplace-fees-and-commissions#per-unit-fee) dari penerbitan Terbatas, serta Robux yang diperoleh dari penjualan item.
Hanya pemegang hak IP tahu apa hak yang mereka miliki dan siapa yang telah diberi izin untuk menggunakan kreasi mereka.Karena itu, kami bergantung pada pemilik hak untuk memberi tahu kami apa yang mereka percaya melanggar hak mereka dengan mengajukan laporan penghapusan .
Jika Anda menemukan konten di Roblox yang menurut Anda melanggar hak IP Anda, silakan lihat [Panduan DMCA](/docs/id-id/production/publishing/dmca-guidelines#what-is-the-dmca) kami untuk informasi tambahan tentang cara mengirim pemberitahuan penghapusan hak intelektual kepada kami.
* Mengirim pemberitahuan penghapusan IP kepada kami adalah proses hukum.
* Hanya pemilik hak atau perwakilan yang berwenang dapat melaporkan konten yang melanggar hak kekayaan intelektual mereka.
* Jika Roblox menerima pemberitahuan penghapusan tentang konten dari seseorang selain pemilik IP atau perwakilan pemilik, Roblox tidak dapat mengambil tindakan hukum terhadap pelanggar kecuali dihubungi oleh pemilik sebenarnya.
## [IP yang dibuat oleh Roblox](#ip-yang-dibuat-oleh-roblox)
Apa yang kami bagikan di atas sama berlaku untuk item yang kami buat juga.Kami menemukan bahwa sebagian besar keluhan yang kami lihat tentang salinan item yang dibuat oleh Roblox sebenarnya tidak melanggar IP kami .Kami melaksanakan hak kami sendiri ketika item melanggar IP kami, tetapi perlindungan IP tidak harus meluas ke setiap ide yang dipresentasikan dalam karya, tetapi elemen asli dan unik dari karya.
Sebagai contoh, Roblox dapat mempublikasikan item virtual yang merupakan tiruan dari item biasa dan umum di dunia nyata di mana tak terhitung versi (baik fisik maupun digital) sudah ada dari banyak pembuat yang berbeda.Ini mungkin topi bisbol tanpa merek atau [kerucut lalu lintas orange](https://www.roblox.com/catalog/1082932/Traffic-Cone).Dengan begitu sedikit elemen yang membedakan item yang dibuat oleh Roblox, bahkan item yang tampak serupa dengan kreasi kami mungkin tidak melanggar hak IP kami.
<img src='https://prod.docsiteassets.roblox.com/assets/art/Traffic-Cone.png' alt='' title='' width='250px' height='' />
*Kone lalu lintas yang dibuat oleh Roblox.Hanya karena pencipta lain membuat kerucut lalu lintas, Roblox tidak akan meminta penghapusan kerucut lalu lintas lain yang dibuat oleh pencipta lain.*
| 21 |
https://create.roblox.com/docs/id-id/marketplace/moderation
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Marketplace
Bahasa Indonesia
Masukan
# Moderasi
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/marketplace/moderation).
Saat mengunggah aset ke Pasar, tim Moderasi meninjau item sebelum Anda dapat menjual item.Proses ini bisa memakan waktu hingga 24 jam.Setelah disetujui, Roblox menetapkan item Anda sebagai "Siap Dijual" di Dashboard Pencipta atau di dalam Studio.
Untuk memastikan bahwa aset Anda memiliki kesempatan terbaik untuk membersihkan moderasi dengan sukses, pastikan aset Anda mematuhi [Kebijakan Pasar](/docs/id-id/marketplace/marketplace-policy) dan bahwa metadata, seperti judul dan deskripsi, mengikuti [praktik terbaik umum](/docs/id-id/production/publishing/publish-experiences-and-places#metadata-best-practices).
Moderasi dapat terjadi setelah item melewati moderasi awal.Jika Roblox menghapus item dengan penjualan, Roblox mengembalikan uang kepada siapa pun yang membeli item dan membatalkan pembayaran tertunda untuk item itu.
Jika Anda percaya bahwa aset Anda telah di moderasi secara tidak benar, Anda dapat [mengajukan banding](https://en.help.roblox.com/hc/en-us/articles/360000245263-Appeal-Your-Content-or-Account-Moderation) dengan staf moderasi kami.
Jika Anda percaya bahwa aset melanggar IP Anda, atau bahwa salah satu aset Anda telah dihapus secara tidak benar karena IP, kirimkan permintaan [DMCA](/docs/id-id/production/publishing/dmca-guidelines) .
## [Aset arsip](#aset-arsip)
Menyimpan aset memungkinkan Anda untuk menghapus aset dari platform Roblox.Proses ini dapat digunakan untuk mengarsipkan item avatar 2D dan 3D.Pada saat ini, pengarsipan Item dan Bundel Terbatas tidak didukung.
Anda dapat meminta arsip permanen satu kali dari item Anda sendiri dengan mengisi form dukungan [di sini](https://www.roblox.com/support) dan memilih "Permintaan Arsip Aset" di bawah kategori DMCA.Proses ini mendukung permintaan merek dagang dan hak cipta.
Silakan sertakan informasi berikut untuk menyimpannya secara permanen:
* Permintaan eksplisit untuk menyimpan konten Anda.
* Tautan URL atau ID aset konten yang ingin Anda arsipkan.
Proses ini bukan pengganti untuk menjadi waspada tentang tidak melanggar hak IP orang lain saat membuat dan mengunggah konten.
| 22 |
https://create.roblox.com/docs/id-id/marketplace/frequently-asked-questions
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. Marketplace
Bahasa Indonesia
Masukan
# Pertanyaan yang sering ditanyakan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/marketplace/frequently-asked-questions).
Apa yang perlu saya lakukan untuk memenuhi syarat untuk dijual di Marketplace?
Pencipta yang diverifikasi ID , memiliki Roblox Premium 1000 atau 2200 , dan konsisten mengikuti Standar Komunitas kami dan Kebijakan Pasar , dapat mengunggah, upload, dan menjual di Pasar.Persyaratan kelayakan ini memungkinkan kami untuk lebih efektif menegakkan kebijakan Marketplace kami dan mencegah pelanggar dari menghindari moderasi.Anda dapat mempelajari lebih lanjut tentang persyaratan untuk diunggah dan dipublikasikan sebagai individu atau kelompok [di sini](/docs/id-id/marketplace/marketplace-policy#creator-requirements) .Roblox juga memerlukan [publikasi lanjutan](/docs/id-id/marketplace/marketplace-fees-and-commissions#publishing-advance) untuk semua item yang dipublikasikan di Marketplace, dengan pengecualian item terbatas gratis.Sebuah kemajuan penerbitan adalah biaya awal yang dapat dikembalikan yang Anda bayarkan saat mempublikasikan item.
Mengapa Roblox menyediakan persyaratan kelayakan yang lebih transparan untuk membuat dan menjual?
Dengan memberikan persyaratan kelayakan yang lebih transparan, kami membuatnya mungkin bagi komunitas pencipta yang lebih besar dan lebih beragam untuk mempublikasikan item dan mengembangkan bisnis mereka di Roblox.
Bisakah saya menerbitkan sebagai bagian dari kelompok dan sebagai individu?
Ya! Pencipta dapat dipublikasikan sebagai bagian dari kelompok dan sebagai individu.Anda dapat membaca lebih lanjut tentang persyaratan untuk dipublikasikan sebagai kelompok dan sebagai individu [di sini](/docs/id-id/marketplace/marketplace-policy#creator-requirements) .
Jenis item apa yang bisa saya buat?
Pencipta dapat membuat item avatar 3D yang termasuk pakaian, aksesori, tubuh, dan kepala.Pembuat dapat memilih untuk membuat item yang tidak terbatas (tidak terbatas jumlahnya) atau [Terbatas](/docs/id-id/marketplace/marketplace-fees-and-commissions#limiteds) (item 3D dengan jumlah tetap).
Mengapa Roblox memiliki kemajuan penerbitan?
Ketika jumlah item dalam satu kategori naik lebih cepat dari minat komunitas di kategori itu, itu dapat membuat lebih sulit bagi orang untuk menemukan item unik dan bagi pencipta untuk mendapatkan.Sebuah kemajuan penerbitan memungkinkan kami untuk meningkatkan bar pada penjualan di Marketplace dengan tujuan mendorong lebih banyak kreasi asli dan unik.Anda dapat mempelajari lebih lanjut tentang Publikasi Advance [di sini](/docs/id-id/marketplace/marketplace-fees-and-commissions#publishing-advance) .
Apakah perkembangan penerbitan akan pernah berubah?
Ya.Saat pasar kami berkembang, kami akan mengevaluasi kembali publikasi maju kami dari waktu ke waktu.Kami mengharapkan kemajuan ini untuk berubah 2 \- 3 kali per kuartal paling banyak.
Apakah ada batasan pada jumlah item yang dapat kami unggah dan publikasikan?
Tidak ada batasan pada jumlah aksesori 3D, pakaian, tubuh, atau kepala yang dapat Anda unggah dari Studio.Setelah item Anda diunggah, Anda dapat mempublikasikan berapa pun jumlah item tidak Terbatas dan hanya 1 item Terbatas per hari.
Mengapa Premium adalah persyaratan?
Kami peduli dengan menciptakan pasar dengan item yang disukai orang dan di mana kreativitas dilindungi.Kami juga peduli dengan memastikan Marketplace tetap menjadi ruang aman dan sipil untuk semua orang.Memerlukan agar pencipta memiliki Premium dan diverifikasi ID membawa lebih banyak pertanggungjawaban ke ekosistem dan memotivasi pencipta yang ingin menjual di Pasar untuk mempublikasikan item yang mereka yakini akan terjual.
Apakah lantai harga akan pernah berubah?
Ya.Sistem kami dapat membantu mendukung harga yang lebih cerdas untuk lebih mencerminkan kondisi pasar dengan secara otomatis menetapkan harga terendah di kategori item berdasarkan permintaan.Kami juga memberikan kontrol kepada pencipta yang memungkinkan mereka menetapkan aturan untuk berapa banyak yang harus dikenakan biaya untuk barang\-barang mereka terkait dengan harga dinamis ini.Kami yakin ini akan membantu memastikan pencipta dapat menghasilkan sambil memberi konsumen lebih banyak akses ke item dengan harga pasar yang adil.
Dapatkah pembuat masih membuat item gratis? Berapa biaya untuk mempublikasikan item gratis?
Ya, pembuat dapat membuat item Terbatas gratis hanya dan ini akan dikenakan biaya untuk setiap unit yang dibuat ( [biaya per unit](/docs/id-id/marketplace/marketplace-fees-and-commissions#per-unit-fee) ).Pada hari ini, biaya per unit untuk item Terbatas gratis adalah 100 Robux.Biaya per unit ini akan terus menjadi dinamis dan dapat diubah di masa depan.
Berapa banyak yang bisa saya dapatkan dari menjual barang saya di Marketplace?
Pencipta akan mendapatkan setidaknya 30% dari keseluruhan penjualan barang.Sisa dibagikan antara platform dan, jika item Anda dijual dalam pengalaman, pengembang yang menciptakan pengalaman itu (yang bisa menjadi Anda).Anda dapat mempelajari tentang pendapatan dari membuat, menjual, dan menjual ulang item avatar [di sini](/docs/id-id/marketplace/marketplace-fees-and-commissions).
Apakah ini berarti Anda menyaksikan matahari terbenam [Program UGC](https://devforum.roblox.com/t/updates-and-changes-to-the-ugc-catalog-application/1974990)?
Ya, kami akan menenggelamkan proses aplikasi warisan untuk bergabung dengan Program UGC.Pencipta yang merupakan bagian dari Program UGC yang secara konsisten memenuhi persyaratan kelayakan kami yang disebutkan di atas dapat terus membuat, mempublikasikan, dan menjual barang di Pasar.
Bagaimana Roblox memastikan pencipta mengikuti Standar Komunitas dan Kebijakan Pasar?
Kami baru\-baru ini menyempurnakan penegakan kami dan sekarang dapat menarik akses ke kreasi sementara atau permanen untuk pencipta yang melanggar kebijakan kami.Perubahan kami termasuk memerlukan verifikasi ID untuk dijual di Pasar, yang membantu kami mencegah orang dengan mudah membuat akun alternatif untuk bergabung kembali dengan program dan menghindari moderasi.
Bagaimana saya bisa melindungi properti intelektual saya [(IP)](/docs/id-id/marketplace/intellectual-property) ?
Pemilik IP adalah orang\-orang yang paling berada di posisi terbaik untuk memberi tahu kami apa yang mereka percaya melanggar hak mereka.Gunakan [Manajer Hak](/docs/id-id/production/publishing/rights-manager) untuk mengelola permintaan penghapusan pelanggaran IP.Anda dapat menggunakan Manajer Hak untuk melaporkan pengalaman, item avatar, dan aset seperti model, audio, dan gambar yang melanggar IP Anda. Roblox menyelidiki setiap laporan dan mengambil actionyang tepat, yang dapat termasuk menghapus atau menonaktifkan konten yang melanggar, dan, dalam situasi yang tepat, mengakhiri akun pengguna yang telah berulang kali melanggar IP orang lain.
Salah satu item saya dihapus. Bagaimana saya mengajukan banding?
Semua keputusan moderasi dapat diberikan keluhan melalui halaman [apel kami](https://www.roblox.com/report-appeals#/).
Bisakah saya menurunkan materi pelanggaran saya sendiri?
Anda dapat mengirim permintaan untuk mengarsipkan item yang diunggah. Lihat [Mengarsipkan Aset](/docs/id-id/marketplace/moderation#archiving-assets) untuk lebih banyak rincian.
Apa perbedaan antara permintaan DSA dan permintaan DMCA? Apa yang terjadi setelah saya mengajukan permintaan itu?
Kami menyediakan beberapa saluran berbeda untuk melaporkan konten yang mungkin melanggar yang ditemukan di Marketplace kami.Saluran ini memiliki kasus penggunaan yang berbeda dan kami meminta orang yang membuat laporan untuk memilih salah satu yang paling sesuai dengan situasi.Setelah Anda mengirim laporan atau permintaan ke channelyang benar, itu akan diperiksa dan diselidiki, dan tindakan yang tepat akan diterapkan jika konten terbukti melanggar hukum atau panduan yang dipantau saluran.
DSA:
Jika Anda berlokasi di Uni Eropa (UE) yang ingin melaporkan konten yang menurut mereka melanggar hukum negara anggota UE, Anda dapat menggunakan formulir laporan konten ilegal kami [Formulir Laporan Konten Ilegal](https://www.roblox.com/illegal-content-reporting).Proses ini tersedia sebagai bagian dari pembaruan terbaru Roblox dalam menanggapi Undang\-Undang Layanan Digital Uni Eropa (DSA) dan hanya boleh digunakan oleh warga UE untuk melaporkan konten yang diyakini melanggar hukum UE dan Negara Anggota.
DMCA:
Jika Anda percaya bahwa hak kekayaan intelektual Anda sendiri telah dilanggar atau dilanggar oleh aksesori yang dibuat oleh pengguna, pakaian, tubuh, atau kepala, Anda dapat mengirim permintaan DMCA melalui [Manajer Hak](/docs/id-id/production/publishing/rights-manager).Manajer Hak menangani pelanggaran hak cipta apa pun yang Anda miliki atau diizinkan untuk dilaporkan atas nama.Jika Anda bukan pemilik hak atau perwakilan yang berwenang, permintaan Anda tidak akan diproses.Untuk aksesori 3D, pakaian, tubuh, atau kepala yang mungkin melanggar Standar Komunitas Roblox, silakan gunakan fitur Laporan Penyalahgunaan yang tersedia di halaman katalog item atau submit laporan melalui [tiket dukungan](https://www.roblox.com/support).
| 23 |
https://create.roblox.com/docs/id-id/studio/setup
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Pengaturan Roblox Studio
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/setup).
Buat pengalaman 3D imersif di Roblox dengan Roblox Studio , aplikasi gratis yang tersedia di Windows dan Mac.
## [Persyaratan sistem](#persyaratan-sistem)
| | MINIMUM | RECOMMENDED |
| --- | --- | --- |
| Versi OS | Windows 10macOS 10\.14 | Windows 11macOS 14\+ |
| Ingatan (RAM) | 3 GB | 8 GB |
| Resolusi | | 1600×900 atau lebih tinggi |
## [Instalasi](#instalasi)
1. Klik tombol Download Studio berikutnya.
Download Studio
2. Di dialog pop\-up, klik tombol Download Studio .
3. Temukan instalator Studio di riwayat unduhan browser Anda dan klik dua kali file tersebut.
* Di Windows, file tersebut adalah RobloxStudio.exe .
* Di Mac, file tersebut adalah RobloxStudio.dmg .
4. Setelah Studio selesai diinstal, konfirmasi pop\-up ditampilkan. Klik tombol Luncurkan Studio .
5. Masuk ke Studio dengan akun Roblox Anda (jika Anda tidak memiliki akun, buat satu di [roblox.com](https://www.roblox.com/) ).
## [Kustomisasi](#kustomisasi)
Banyak opsi kustomisasi dapat diakses melalui Pengaturan Studio ( AltS di Windows; ⌥S di Mac).Anda dapat dengan cepat menemukan pengaturan yang dikenal dengan mengetik kata kunci ke bidang pencarian di bagian atas jendela.Sebagai contoh, cari theme untuk secara eksplisit mengatur Studio ke tema gelap atau tema ringan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Studio-Settings-Layout.png' alt='A close up view of the Studio Settings window.' title='' width='750' height='' />Selain pengaturan umum, Anda dapat menyesuaikan tata letak jendela Studio [untuk paling sesuai dengan alur kerja Anda](/docs/id-id/studio/ui-overview#layout-customization).
## [Pembaruan](#pembaruan)
Berbeda dengan beberapa mesin lain, setiap pengalaman dijalankan pada versi terbaru dari Roblox Engine.Anda harus menjaga Studio up\-to\-date untuk menggunakan API dan fitur terbaru.
Jika versi Studio saat ini sudah kadaluarsa, Anda akan melihat tombol Pembaruan Tersedia di pojok kanan atas.Mengklik tombol akan meminta Anda untuk menyimpan/tutup tempat yang saat ini terbuka sehingga Studio dapat secara otomatis diperbarui dan dimulai ulang.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Update-Prompt.png' alt='Studio's Model tab with the Update Studio button highlighted.' title='' width='754' height='' />
## [Fitur beta](#fitur-beta)
Banyak fitur beta tersedia melalui menu File Fitur Beta Studio.Setelah Anda mengaktifkan fitur beta, klik tombol Simpan dan Anda akan diminta untuk memulai ulang Studio agar fitur berlaku.
| 24 |
https://create.roblox.com/docs/id-id/assistant/prompt-engineering
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [Assistant for Studio](/docs/id-id/assistant/guide)
Bahasa Indonesia
Masukan
# Panduan instruksi asisten dan contoh
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/assistant/prompt-engineering).
[Bagikan prompt dan pengalaman Anda](https://devforum.roblox.com/t/check-out-the-generative-ai-stream-and-let-us-know-your-best-prompts/3215844) di forum Roblox sehingga kami dapat membuat Asisten lebih baik!
Dokumen ini memberikan panduan tentang meminta Asisten dan memberikan contoh dan inspirasi tentang apa yang dapat dilakukan Asisten.
## [Jadilah spesifik](#jadilah-spesifik)
Jika Asisten gagal, tambahkan lebih banyak rincian ke prompt Anda dan coba lagi.Gunakan nama instansi persis seperti yang mereka diucapkan, spesifikasikan fungsi mana yang ingin Asisten gunakan, dan beri tahu Asisten jenis apa yang bekerja dengannya, seperti bagian atau model.
| Tidak spesifik | Lebih spesifik |
| --- | --- |
| Tempatkan pohon dalam lingkaran. | Tempatkan 10 salinan model "pine\_tree" di ReplicatedStorage dalam lingkaran radius 30 stud di sekitar SpawnLocation. |
| Buat bagian bergerak. | Tambahkan skrip untuk membuat "my\_part" bergerak ke atas dan ke bawah 10 kancing berulang kali menggunakan TweenService. |
| Bagaimana saya bisa merancang loop inti? | Bantu saya merancang loop inti yang menyenangkan untuk gamesaya.Saya ingin membangun permainan di mana pemain dapat berburu harta karun sebagai bajak laut.Mereka juga bisa membeli dan meningkatkan kapal bajak laut dan bertempur satu sama lain. |
## [Gunakan pilihan Anda](#gunakan-pilihan-anda)
Seleksi adalah cara yang bagus untuk menentukan objek atau kumpulan objek yang ingin Anda referensikan dalam prompt Anda.Pilih beberapa objek dan minta Asisten untuk memodifikasinya, membuat duplikat dan menempatkannya di suatu tempat, atau melanjutkan pola posisi seperti menjaga penempatan di baris.
## [Edit waktu dan waktu eksekusi](#edit-waktu-dan-waktu-eksekusi)
Asisten terkadang membingungkan perbedaan antara waktu编辑 dan waktu eksekusi.Jika Anda meminta Asisten untuk mengambil action, kemungkinan besar akan memihak untuk melakukannya saat diedit.Jika Anda ingin tindakan terjadi selama waktu eksekusi, minta Asisten untuk menyisipkan skrip yang melakukan action.Sebagai contoh, beritahu Asisten "tambahkan skrip untuk membuat waktu hari 8:00 AM" bukan "buat waktu hari 8:00 AM."
## [Terus mencoba](#terus-mencoba)
Jangan putus asa jika Asisten tidak berfungsi persis seperti yang Anda inginkan pertama kali.Seringkali, membuat perubahan kecil dan mencoba lagi dapat menghasilkan hasil yang lebih baik.Banyak alat AI tidak deterministik, artinya mereka tidak membuat output yang sama persis setiap kali Anda memintanya melakukan sesuatu.Ada beberapa variasi, yang dapat Anda akses dan kendalikan menggunakan perubahan untuk prompt Anda.
AI dalam keadaan saat ini membutuhkan pekerjaan.Dibutuhkan waktu untuk memahami cara terbaik berbicara kepada Asisten, apa yang dapat dilakukannya, dan cara mendapatkan apa yang Anda inginkan darinya.
## [Petunjuk multi langkah](#petunjuk-multi-langkah)
Pertimbangkan menggunakan prompt multi langkah untuk mendorong Asisten berpikir.Alih\-alih menanyakan "Bisakah Anda menjelaskan skrip ini kepada saya?" dan menempelkan di skrip, tanyakan untuk menjelaskan langkah demi langkah dengan memisahkan pertanyaan dari skrip dengan \#\#\#.Pemisahan ini membantu Asisten membongkar dan mengatur ulang informasi untuk memberikan jawaban yang lebih baik.
Cepat
Tanggapan Asisten
*Dapatkah Anda menjelaskan apa yang dilakukan skrip ini secara langkah demi langkah?*
\#\#\#*bagian lokal \= workspace.Part*
*fungsi lokal onTouched(otherPart)* \*print(part.Name .. " bertabrakan dengan " .. otherPart.Name)\**akhir*
*bagian.Sentuh:Connect(onTouched)*
\#\#\#
## [Contoh](#contoh)
Contoh\-contoh ini menunjukkan berbagai tugas yang dapat dilakukan Asisten hari ini.Beberapa dari mereka mungkin membutuhkan beberapa percobaan bagi Anda untuk direproduksi, tetapi beri mereka percobaan dan lihat apa yang bisa Anda hasilkan sendiri.
### [Mechanik permainan \- Tembak bola api yang meledak](#mechanik-permainan---tembak-bola-api-yang-meledak)
Perintah: Dorongkan bola api menjauh dari pemain ke arah yang dihadapkan pemain saat pemain menekan "e".Buat bola api meledak saat menyerang sesuatu.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt16.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt16.webm)
### [Mechanik permainan \- Buat sistem tim dan atribusikan pemain](#mechanik-permainan---buat-sistem-tim-dan-atribusikan-pemain)
Prompt: Tambahkan skrip untuk membuat sistem tim (merah, biru, hijau, kuning) dan atribusikan setiap pemain secara acak ke tim.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt17.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt17.webm)
### [Mekanik permainan \- Gaya lari kuil konstan berjalan](#mekanik-permainan---gaya-lari-kuil-konstan-berjalan)
Prompt: Buat karakter saya berjalan terus ke depan seperti di game lari kuil.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt3.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt3.webm)
### [Mechanik permainan \- Kekuatan api naik](#mechanik-permainan---kekuatan-api-naik)
Prompt: Tambahkan skrip yang membuat pemain menyala api dan melompat 3 kali lebih tinggi jika mereka menekan "q".Api harus dilampirkan ke pemain dan bergerak bersama mereka.Jika mereka menekan "q" lagi, matikan api dan reset kekuatan lompatan.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt4.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt4.webm)
### [Mechanik permainan \- Laser NPC](#mechanik-permainan---laser-npc)
Prompt: Tambahkan skrip yang membuat penembakan ini menjadi laser menggunakan bagian tipis panjang yang biru dan neon pada pemain jika mereka berada dalam 30 stud.
Tambahkan skrip untuk membuat ini terlihat ke arah dan perlahan\-lahan bergerak ke arah pemain terdekat jika mereka berada dalam 50 stud.Hanya bergerak di sumbu x dan z, pertahankan sumbu y konstan.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt9.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt9.webm)
### [Mechanik permainan \- NPC interaktif](#mechanik-permainan---npc-interaktif)
Perintah: Ini adalah NPC.Tambahkan perintah yang memungkinkan pemain berinteraksi dengannya.Jika pemain berinteraksi, memiliki NPC mengatakan "halo \[nama pemain]" di mana nama pemain adalah nama aktual pemain, dalam pop up teks.
Tambahkan skrip yang membuat NPC ini selalu melihat ke arah pemain terdekat.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt2.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt2.webm)
### [Mechanik permainan \- Patroli NPC](#mechanik-permainan---patroli-npc)
Prompt: Tambahkan skrip untuk membuat NPC ini bergerak perlahan di antara startpart dan endpart berulang kali.Ini harus menghadap bagian dan kemudian pindah ke sana, lalu menghadap bagian lain dan pindah ke sana.Jika pemain masuk dalam 10 stud, ubah NPC menjadi merah dan membuatnya mengejar pemain.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt1.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt1.webm)
### [Mechanik permainan \- Perbarui skorboard](#mechanik-permainan---perbarui-skorboard)
Perintah: Tambahkan skrip yang menghapus ini dan menambahkan 100 ke skor pemain.
Tambahkan skrip untuk menampilkan skor pemain di papan skor.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt11.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt11.webm)
### [Kamera \- Terkunci ke atas ke bawah](#kamera---terkunci-ke-atas-ke-bawah)
Prompt: Tambahkan skrip yang mengunci kamera dalam pandangan atas ke bawah pada pemain dan mengikuti pemain, memastikan pemain tetap berada di tengah layar.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt13.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt13.webm)
### [Kamera \- Terkunci pada orang pertama](#kamera---terkunci-pada-orang-pertama)
Prompt: Buat skrip untuk mengunci kamera dalam pandangan orang pertama.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt15.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt15.webm)
### [UI \- Menu drop\-down](#ui---menu-drop-down)
Prompt: Buat menu drop down dengan 5 item.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt18.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt18.webm)
### [UI \- Bilah kesehatan](#ui---bilah-kesehatan)
Prompt: Tambahkan bagian di tanah, ketika seorang pemain menyentuhnya, itu mengurangi kesehatan sebesar 10%.Tempatkan bilah kesehatan UI di bagian tengah atas layar yang berubah merah saat kesehatan pemain kurang dari 20%.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt5.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt5.webm)
### [UI \- HUD Mudah](#ui---hud-mudah)
Prompt: Buat tampilan kepala di StarterGui.Tambahkan bilah kesehatan di bagian atas kanan, dan label teks dengan nama pemain di bawahnya.Di bagian kanan bawah, tambahkan 4 tombol dalam bentuk berlian, dengan "Ramuan" di atas, "Senjata" di kiri, "Inventaris" di bagian bawah, dan "Spesial" di sebelah kanan.Buat warna jatuh berwarna tema.
<img src='https://prod.docsiteassets.roblox.com/assets/assistant/prompt10.png' alt='' title='' width='90%' height='' />
### [Membangun \- Menyebarkan objek dengan randomisasi](#membangun---menyebarkan-objek-dengan-randomisasi)
Perintah: Tambahkan 0\-5 instans yang dipilih "Mushroom" di sekitar setiap "RedwoodTree\-Var01".
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt19.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt19.webm)
### [Membangun \- Siklus malam/siang dengan lampu jalan](#membangun---siklus-malamsiang-dengan-lampu-jalan)
Prompt: Tambahkan skrip yang mengubah waktu hari dengan 1 jam setiap detik.Mulai pukul 3 sore.Pada pukul 19:00, nyalakan kecerahan sorotan setiap sampai 10\.Pada pukul 8 pagi, turunkan kecerahan setiap sorotan ke 0\.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt7.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt7.webm)
### [Membangun \- Jembatan penangkapan berbasis fisika](#membangun---jembatan-penangkapan-berbasis-fisika)
Perintah: Buat jembatan tali.Buat 10 papan kayu yang lebar 5 sudut dan panjang 2 sudut.Letakkan mereka dalam satu baris.Tambahkan batasan rop di setiap sisi bagian, menghubungkan masing\-masing ke bagian sebelum dan setelahnya.Jadikan semua batas tali terlihat, ikat bagian ke\-1 dan ke\-10, dan tambahkan detektor geser pada bagian ke\-1 dan ke\-10\.
<img src='https://prod.docsiteassets.roblox.com/assets/assistant/prompt12.png' alt='' title='' width='90%' height='' />
### [Membangun \- Tambahkan asap ke perapian](#membangun---tambahkan-asap-ke-perapian)
Prompt: Sisipkan bata tak terlihat yang tidak dapat bertabrakan ke setiap perapian di setiap rumah.Bata harus memiliki partikel di dalamnya yang membuat asap yang mengalir ke atas, dan asap harus putih.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt14.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt14.webm)
### [Membangun \- Ganti nama instansi](#membangun---ganti-nama-instansi)
Perintah: Ganti semua objek "script kosong" menjadi "Script\+uniqueID".
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt8.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt8.webm)
### [Membangun \- Buat medan](#membangun---buat-medan)
Prompt: Buat wilayah medan dengan bukit bergulir.
<img src='https://prod.docsiteassets.roblox.com/assets/assistant/prompt6.png' alt='' title='' width='90%' height='' />
### [Membangun \- Tambahkan perilaku pada skala](#membangun---tambahkan-perilaku-pada-skala)
Perintah: Tambahkan skrip untuk membuat sorotan di folder StreetLights berkedip secara acak.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt20.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt20.webm)
### [Membangun \- Gantikan kotak abu\-abu dengan aset](#membangun---gantikan-kotak-abu-abu-dengan-aset)
Perintah: Ganti masing\-masing bagian yang dipilih dengan model nama yang sama saat ini dalam model data di dalam Folder AssetLibrary di bawah ruang kerja.Sebagai contoh, jika bagian disebut "Rumah Suburban", cari model yang disebut "Rumah Suburban" dan ganti bagian dengan model itu.
[https://prod.docsiteassets.roblox.com/assets/assistant/prompt21.webm](https://prod.docsiteassets.roblox.com/assets/assistant/prompt21.webm)
| 25 |
https://create.roblox.com/docs/id-id/studio/ui-overview
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Antarmuka studio
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/ui-overview).
## [Alat bilah](#alat-bilah)
Alat bilah alat berada di bagian atas Studio.Tombol dan alat yang terlihat di bilah berubah saat Anda mengklik pada [Rumah](/docs/id-id/studio/home-tab), [Model](/docs/id-id/studio/model-tab), [Avatar](/docs/id-id/studio/avatar-tab), [Tes](/docs/id-id/studio/test-tab), [Pandangan](/docs/id-id/studio/view-tab), dan [Plugin](/docs/id-id/studio/plugins-tab) tab.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Tabs-Labeled.png' alt='Studio's toolbar with the Home, Model, Avatar, Test, View, and Plugins tabs highlighted.' title='' width='800' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-A.png' alt='' title='' width='40' height='' />Tab [Rumah](/docs/id-id/studio/home-tab) berisi alat dasar untuk memanipulasi objek 3D dan menguji pengalaman Anda.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-B.png' alt='' title='' width='40' height='' />Tab [Model](/docs/id-id/studio/model-tab) berisi alat untuk memanipulasi objek 3D di ruang kerja, membuat model terperinci, bekerja dengan batasan fisik, dan menambahkan objek canggih.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-C.png' alt='' title='' width='40' height='' />Tab [Avatar](/docs/id-id/studio/avatar-tab) berisi alat khusus untuk membuat dan memasang aksesori, mengimpor meshes khusus, membangun rig default, dan membuat animasi.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-D.png' alt='' title='' width='40' height='' />Tab [Tes](/docs/id-id/studio/test-tab) berisi alat untuk menguji pengalaman, menyimulasikan banyak klien, dan meniru perangkat yang berbeda.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-E.png' alt='' title='' width='40' height='' />Tab [Tampilan](/docs/id-id/studio/view-tab) memungkinkan Anda untuk menyalakan berbagai jendela Studio, serta beberapa fitur tampilan.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-F.png' alt='' title='' width='40' height='' />Tab [Plugin](/docs/id-id/studio/plugins-tab) berisi alat untuk mengelola [plugin](/docs/id-id/studio/plugins), mengonfigurasi lokalisasi, dan membuat animasi.Setiap plugin yang Anda instal juga dapat menambahkan tombol ke tab ini.
## [Jendela pandang 3D](#jendela-pandang-3d)
Jendela pandang 3D mewakili [Workspace](/docs/id-id/reference/engine/classes/Workspace) dari tempat.Dari sini, Anda dapat memindahkan kamera di sekitar dunia virtual, memanipulasi objek dengan mouse, dan menguji pengalaman tanpa meninggalkan Studio.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Editor-Window.jpg' alt='An example viewport display of a desert environment with multiple stone pillars. One of the pillars displays movement visual aids from the Move tool.' title='' width='100%' height='' />
*Jendela pandang 3D di Roblox Studio*
### [Kontrol kameranya](#kontrol-kameranya)
Di dalam jendela pandang, Anda dapat memindahkan kamera dengan kontrol berikut. Lihat juga [Jalan pintas studio](/docs/id-id/studio/shortcuts#camera-controls) untuk jalan pintas tombol tambahan.
| Kunci/Jalan Singkat | Tindakan |
| --- | --- |
| WASD | Pindahkan kamera ke depan/kiri/belakang/kanan. |
| QE | Memindahkan kamera ke bawah/ke atas. |
| Shift | Dikombinasikan dengan tombol gerakan apa pun, mengubah kecepatan kamera. Jika diinginkan, Anda dapat [kustomisasi](/docs/id-id/studio/setup#customization) kecepatan kamera dalam pengaturan Studio. |
| F | Fokuskan kamera pada bagian yang dipilih. |
| Tombol Mouse Kanan | Saat ditekan, menyeret mouse memindahkan pandangan kamera di sekitar. |
| Roda Gulir Tikus | Perbesar kamera ke dalam atau ke luar. |
| Tombol Tengah Mouse | Saat ditekan, menyeret mouse memindahkan kamera. |
| Tombol Mouse Kanan \& Roda Gulir Mouse | Mengklik tombol mouse kanan dan menggulir roda mouse ke atas meningkatkan kecepatan gulir kamera.Sebaliknya, menekan tombol mouse kanan dan menggulir roda mouse bawah mengurangi kecepatan gulir kamera. Kecepatan gulir kamera juga dapat disesuaikan dari opsi visualisasi di menu sudut kanan atas tampilan 3D. |
### [Pemilihan objek](#pemilihan-objek)
Saat Anda mengarahkan kursor ke bagian dan model di jendela, mereka disoroti untuk menunjukkan pilihan potensial mereka.Anda dapat memilih objek tercantum dengan mengkliknya, atau Anda dapat memilih beberapa objek dengan menahan Shift , Ctrl , atau ⌘ saat Anda mengarahkan dan mengkliknya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Editor-Window-Object-Selection.jpg' alt='A warehouse environment with the stairs and multiple pallet box objects with a blue highlight to signify that they are selected in the 3D viewport.' title='' width='800' height='' />
#### Siklus pemilihan
Di lingkungan yang lebih kompleks atau saat diperbesar, objek umumnya akan tersembunyi dari pandangan Anda oleh objek lain di depan.Untuk memilih objek tersembunyi tanpa memindahkan kamera, tahan Alt atau ⌥ dan klik untuk melakukan seleksi siklus ke objek berikutnya di belakang objek yang dipilih saat ini.
[https://prod.docsiteassets.roblox.com/assets/studio/general/Selection-Cycling.mp4](https://prod.docsiteassets.roblox.com/assets/studio/general/Selection-Cycling.mp4)
*Siklus pemilihan*
#### Anak\-anak atau orang tua
Ketika satu atau lebih objek atau [model](/docs/id-id/parts/models) dipilih di jendela [Explorer](/docs/id-id/studio/explorer), Anda dapat memilih semua anak mereka dengan mengklik kanan dan memilih Pilih Anak\-Anak dari menu kontek.Demikian pula, mengklik kanan dan memilih Pilih Orangtua (s) memilih orangtua langsung dari objek tersebut.
#### Gaya seleksi
Untuk menampilkan garis besar dan/atau kotak batas di sekitar objek yang dipilih, pilih opsi dari menu Gaya Pilihan di tab [Tampilan](/docs/id-id/studio/view-tab).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Selection-Style.png' alt='Studio's View tab with the Selection Style tool highlighted.' title='' width='670' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Selected-Object-Bounding-Box.jpg' alt='A warehouse environment with rope object's selection outline and bounding box highlighted.' title='' width='800' height='' />
### [Opsi visualisasi](#opsi-visualisasi)
Di sudut kanan atas tampilan 3D, Anda dapat dengan cepat beralih atau mengatur opsi visualisasi umum terkait dengan [UI pada layar](/docs/id-id/ui/on-screen-containers), [sumber cahaya](/docs/id-id/effects/light-sources), simulasi fisika, karakter [penemuan jalur](/docs/id-id/characters/pathfinding), dan banyak lagi.Menu juga berisi kontrol untuk melihat/mengatur kecepatan gulir kamera.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Visualization-Options.png' alt='A close up view of the 3D viewport with the Visualization Options button indicated in the upper-right corner.' title='' width='780' height='' />
## [Jendela umum](#jendela-umum)
Anda dapat beralih pada jendela yang umum digunakan melalui tab [Lihat](/docs/id-id/studio/view-tab), termasuk jendela [Explorer](/docs/id-id/studio/explorer), [Properties](/docs/id-id/studio/properties), [Manajer Aset](/docs/id-id/projects/assets/manager), [Kotak Alat](/docs/id-id/projects/assets/toolbox), dan banyak lainnya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-View-Tab.png' alt='Studio's toolbar and View tab with the tab highlighted.' title='' width='876' height='' />
### [Penjelajah](#penjelajah)
Jendela [Penjelajah](/docs/id-id/studio/explorer) terlihat secara default, menunjukkan daftar hierarkis dari setiap objek dan layanan di dalam tempat itu, secara kolektif disebut sebagai model data nya .Layanan yang sering digunakan dalam hierarki termasuk [Workspace](/docs/id-id/reference/engine/classes/Workspace) yang mencerminkan [3D viewport](#3d-viewport) , serta [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) dan [ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Explorer.png' alt='Studio's View tab with the Explorer button highlighted.' title='' width='876' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Parent-Child-Hierarchy.png' alt='Explorer hierarchy showing Camera, Terrain, and SignModel as children of Workspace; Board and Post as children of SignModel' title='' width='320' height='' />
### [Propinsi](#propinsi)
Jendela [Properti](/docs/id-id/studio/properties) memungkinkan Anda menyesuaikan properti objek yang dipilih untuk mengubah tampilan dan perilakunya.Properti objek dibagi menjadi bagian; misalnya, [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) termasuk bagian seperti Penampilan yang memungkinkan Anda untuk mengubah warnanya, material, transparansi, dan banyak lagi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Properties.png' alt='Studio's View tab with the Properties button highlighted.' title='' width='876' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Sections-Example.png' alt='' title='' width='320' height='' />Di bagian bawah jendela, Anda dapat mendefinisikan atribut khusus [untuk objek](/docs/id-id/studio/properties#instance-attributes) yang mirip dengan properti defaultnya.Atribut dan nilainya disimpan dengan tempat/aset Anda dan mereka adalah cara ideal bagi anggota tim untuk bereksperimen dengan nilai yang berbeda selama runtime, bahkan jika mereka tidak memahami kode dasar.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Attributes-Example-B.png' alt='A close up view of the Attributes section of the Properties window.' title='' width='320' height='' />
### [Manajer Aset](#manajer-aset)
Manajer [Aset](/docs/id-id/projects/assets/manager) memungkinkan Anda mengelola tempat, gambar, meshes, audio, dan banyak lagi.Ia juga menyediakan mekanisme untuk mengimpor massal kelompok besar aset.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Asset-Manager.png' alt='Studio's View tab with the Asset Manager button highlighted.' title='' width='776' height='' />
### [Kotak Alat](#kotak-alat)
Kotak alat [berisi pilihan model, gambar, mesh, audio, plugin, video, dan font yang dibuat oleh Roblox atau anggota komunitas Roblox](/docs/id-id/projects/assets/toolbox).Ini juga termasuk semua kreasi yang Anda distribusikan secara pribadi [di Toko Pencipta](/docs/id-id/production/creator-store) atau kreasi yang didistribusikan oleh [kelompok](/docs/id-id/projects/groups) yang Anda miliki.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Toolbox.png' alt='Studio's View tab with the Toolbox button highlighted.' title='' width='776' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/toolbox/Model-Search-Example.png' alt='The Toolbox window.' title='' width='360' height='' />
### [Output](#output)
Jendela [Keluaran](/docs/id-id/studio/output) yang dapat diakses dari tab [Pandangan](/docs/id-id/studio/view-tab), menampilkan kesalahan yang ditangkap dari menjalankan skrip, pesan dari Roblox Engine, pesan dari panggilan ke print() , dan kesalahan dari panggilan ke warn() .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Output.png' alt='Studio's View tab with the Output button highlighted.' title='' width='768' height='' />
### [Bar Perintah](#bar-perintah)
Bar perintah , yang dapat diakses dari tab Tampilan, memungkinkan Anda mengeksekusi kode Luau di luar skrip.Mirip dengan terminal, menekan ↑ atau ↓ saat menggunakan bilah perintah menavigasi ke atas dan ke bawah di antara perintah yang sebelumnya dieksekusi.Mengklik panah kecil di sisi kanan juga mengungkapkan daftar perintah yang sebelumnya dijalankan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Command-Bar.png' alt='Studio's View tab with the Command Bar button highlighted.' title='' width='768' height='' />
## [Kustomisasi tata letak](#kustomisasi-tata-letak)
Antarmuka seret dan lepaskan Studio memungkinkan Anda dengan mudah menyesuaikan tata letak jendela untuk sesuai dengan alur kerja Anda.
### [Posisikan ulang jendela](#posisikan-ulang-jendela)
Anda dapat mengubah posisi jendela apa pun dengan mengklik\-seretkan bilah kepala nya .Saat Anda mulai menyeret jendela, antarmuka menunjukkan zona doking kosong bagian.Jika Anda menyeret pointer mouse ke dalam wilayah kosong, pemilih posisi mengambang muncul di wilayah itu.Menyeret penunjuk di atas "pusat" dari target selektor mengambang menargetkan wilayah kosong sebagai tujuan jendela yang ditarik, ditunjukkan oleh pemburaman wilayah dan menjadi dikelilingi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Docking-Position-Selector-Empty.jpg' alt='Mouse pointer hovering over the 'center' icon of the position selector in an empty docking area, showing that region as the dragged window's destination.' title='' width='880' height='' />
*Kursor mouse melayang di atas ikon "pusat" dari pemilih posisi di area doking kosong*
Jika Anda menyeret poin mouse ke dalam wilayah berpenduduk seperti jendela 3D viewport, pemilih posisi mengambang muncul dengan beberapa opsi untuk tujuan jendela.Sebagai contoh, menyeret penunjuk di atas ikon "kiri" akan menempatkan jendela di sisi kiri wilayah.
Jendela tertinggal
Jendela pandang kanan
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Docking-Position-Selector-Left.jpg' alt='Mouse pointer hovering over the 'left half' icon of the position selector in a populated region, showing the left side of the region as the dragged window's destination.' title='' width='880' height='520' />
### [Jendela kelompok](#jendela-kelompok)
Jika Anda menyeret jendela ke wilayah berpenduduk dan memilih ikon "pusat" dari [pemilih posisi](#reposition-windows), jendela yang ditarik akan digrupkan ke wilayah itu sebagai tab.Ini memungkinkan Anda untuk mengatur kelompok tab dari jendela yang umum digunakan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Docking-Grouped-Tabs.png' alt='An example of an Explorer window if you choose the center icon of the position selection. It includes three tabs at the bottom of the window: the Explorer window, the Properties window, and the Terrain Editor window.' title='' width='320' height='' />
*Tiga jendela dikumpulkan bersama sebagai tab*
### [Pin jendela](#pin-jendela)
Untuk memaksimalkan ruang layar untuk tampilan 3D, Anda dapat menempelkan jendela (atau seluruh kelompok jendela) ke tepi jendela Studio keseluruhan.Setelah disematkan, Anda dapat membuka jendela apa pun sementara dengan mengklik tabnya — ini tidak mengganggu jendela lain, dan jendela yang diperluas akan otomatis tertutup saat Anda mengklik di jendela lain atau klik tabnya lagi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Docking-Pinned-Tabs.jpg' alt='An example 3D viewport where the Explorer, Properties, and Terrain Editor windows are pinned to the right of the Studio window.' title='' width='800' height='' />
*Tiga jendela yang disematkan di sisi kanan jendela Studio*
Untuk menempelkan jendela atau seluruh kelompok [jendela](#group-windows), klik tombol "kelipatan"Alternatifnya, untuk menghapus jendela/kelompok tertempel, buka dengan mengklik tabnya, lalu klik tombol "ekspand" .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Docking-Expand-Collapse.png' alt='A close up view of the Explorer window with the Collapse button highlighted.' title='' width='320' height='' />
### [Jendela mengambang](#jendela-mengambang)
Untuk mengapungkan jendela secara bebas dari jendela lain, cukup seret dan lepaskan tanpa memilih ikon dari penyeleksi posisi mengambang .
## [Pengujian dalam studio](#pengujian-dalam-studio)
Studio menawarkan serangkaian opsi untuk menguji pengalaman sebelum [merilisnya ke publik](/docs/id-id/production/publishing/publish-experiences-and-places#release-to-the-public) .Semua opsi pengujian dapat diakses dari tab [Tes](/docs/id-id/studio/test-tab).
* [Pengujian pembayaran cepat](/docs/id-id/studio/testing-modes#playtest-options) — Memberikan simulasi dekat dari pengalaman yang berjalan di aplikasi Roblox.
* [Simulasi multi\-klien](/docs/id-id/studio/testing-modes#multi-client-simulation) — Membandingkan bagaimana setiap klien "melihat" klien lain dalam pengalaman.
* [Emulasi perangkat](/docs/id-id/studio/testing-modes#device-emulation) — Memberikan wawasan tentang bagaimana kontrol beroperasi di perangkat seluler atau bagaimana tampilan UI di layar menampilkan di berbagai layar dan rasio aspek.
* [Emulasi kontroler](/docs/id-id/studio/testing-modes#controller-emulation) — Akurat meniru [input gamepad](/docs/id-id/input/gamepad) langsung di Studio.
Lihat [Mode pengujian studio](/docs/id-id/studio/testing-modes) untuk informasi lebih lanjut tentang setiap opsi pengujian.
## [Peta bilah alat berikutnya](#peta-bilah-alat-berikutnya)
props.leadIn File \> Fitur Beta \> props.betaName props.leadOutAlat bilah Studio generasi berikutnya memperkenalkan berbagai perbaikan dan optimisasi, termasuk penampilan yang lebih bersih, tab yang dapat disesuaikan dengan koleksi alat Anda sendiri, dan kemampuan untuk menampilkan/menyembunyikan tab sesuai keinginan.Tabel berikut menguraikan alur kerja bilah alat Studio sebelumnya ke kesetaraan generasi berikutnya.
### Umum
| Aksi/Alat | Alur Kerja Lama(s) | Alur Kerja Baru(s) |
| --- | --- | --- |
| [Bermitra](/docs/id-id/projects/collaboration) | Sisi kanan bar mezzanine | no change |
| Pemberitahuan Pencipta | Sisi kanan bar mezzanine | no change |
| [Wakil](/docs/id-id/assistant/guide) | Sisi kanan bar mezzanine atau Tampilkan tab | Sisi kanan bar mezzanin |
| Bantuan Online | Sisi kanan bar mezzanine atau File menu | Aplikasi studio \> Bantuan menu |
| Bagikan | Sisi kanan bar mezzanine | no change |
| Menu Akun | Sisi kanan bar mezzanine | no change |
| [Pengaturan Studio](/docs/id-id/studio/setup#customization) | Menu File | Aplikasi studio ⟩ Pengaturan studio |
| Fitur Beta | Menu File | Aplikasi studio ⟩ File menu ⟩ Fitur beta |
| Simpan ke Roblox / Sebagai... | Menu File | Aplikasi studio ⟩ File menu ⟩ Simpan ke Roblox / Sebagai… |
| Publikasikan ke Roblox / Sebagai... | Menu File | Aplikasi studio ⟩ File menu ⟩ Terbitkan ke Roblox / Sebagai… |
| [Pengaturan Permainan](/docs/id-id/studio/game-settings) | Menu file atau Rumah tab | Aplikasi studio ⟩ File menu ⟩ Pengaturan permainan |
| [Manajemen Plugin](/docs/id-id/studio/plugins-tab#manage-plugins) | Plugin tab | Aplikasi studio ⟩ Plugin menu ⟩ Kelola Plugin |
| Direktori plugin | Plugin tab | Aplikasi studio ⟩ Plugin menu ⟩ Folder Plugin |
### Jendela umum
| Aksi/Alat | Alur Kerja Lama(s) | Alur Kerja Baru(s) |
| --- | --- | --- |
| [Penjelajah](/docs/id-id/studio/explorer) | Lihat tab | 🄐 Rumah tab \> Penjelajah 🄑 aplikasi Studio \> Jendela menu \> Penjelajah |
| [Propinsi](/docs/id-id/studio/properties) | Lihat tab | 🄐 Rumah tab ⟩ Properti 🄑 Aplikasi Studio ⟩ Jendela menu ⟩ Properti |
| [Manajer Aset](/docs/id-id/projects/assets/manager) | Lihat tab | Aplikasi studio ⟩ Jendela menu ⟩ Manajer Aset |
| [Kotak Alat](/docs/id-id/projects/assets/toolbox) | Lihat tab | 🄐 Rumah tab \> Kotak Alat 🄑 Aplikasi Studio \> Jendela menu \> Kotak Alat |
| [Output](/docs/id-id/studio/output) | Lihat tab | 🄐 Aplikasi Studio \> Jendela menu \> Output 🄑 Skrip tab \> Output |
| [Bar Perintah](#command-bar) | Lihat tab | 🄐 Aplikasi Studio \> Jendela menu \> Bilah Perintah 🄑 Skrip tab \> Perintah |
| [Editor Tanah](/docs/id-id/studio/terrain-editor) | Rumah atau Tampilkan tab | Aplikasi studio ⟩ Jendela menu ⟩ 3D \> Tanah |
| browser objek | Lihat tab | Aplikasi studio ⟩ Jendela menu ⟩ Skrip \> Object Browser |
| Pengedit Tag | Lihat tab | Aplikasi studio ⟩ Jendela menu ⟩ Skrip \> Editor Tag |
### Mengedit dan memodelkan
| Aksi/Alat | Alur Kerja Lama(s) | Alur Kerja Baru(s) |
| --- | --- | --- |
| Salin, Potong, Tempel, Duplikasi | Rumah tab | Aplikasi studio \> Edit menu |
| Pilih, Gerakkan, Skala, Putar, Transformasi | Rumah , Model , atau Avatar tab | no change |
| Pemilih mode (geometris vs fisik) | Rumah , Model , atau Avatar tab | no change |
| Tabrakan \& Bergabung dengan Permukaan beralih | Rumah , Model , atau tab Avatar | Pemilih mode \> Opsi di menu popup |
| Putar/Gerakkan geser dan peningkatan | Model atau Avatar tab | Rumah , Model , atau tab Avatar |
| [Pilih/masukkan bagian](/docs/id-id/parts#insert-parts) | Rumah atau Model tab | no change |
| [Pilih/terapkan warna](/docs/id-id/parts#hexagon-map) | Rumah atau Model tab | no change |
| [Pilih/terapkan bahan](/docs/id-id/parts/materials#material-widget) | Rumah atau Model tab | no change |
| [Manajer Bahan](/docs/id-id/parts/materials#material-manager) | Rumah atau Model tab ⟩ Pemilih dropdown bahan ⟩ Manajer bahan | Aplikasi studio ⟩ Jendela menu ⟩ 3D \> Bahan |
| Grup | Rumah atau Model tab | 🄐 Rumah atau Model tab \> Grup 🄑 aplikasi Studio \> Edit menu \> Grup |
| Mengunci | Rumah atau Model tab | 🄐 Rumah atau Model tab \> Mengunci 🄑 aplikasi Studio \> Edit menu \> Mengunci |
| Pengunci | Rumah atau Model tab | 🄐 Rumah atau Model tab \> Anchor 🄑 aplikasi Studio \> Edit menu \> Anchor |
| Tampilkan alat UI | Rumah tab | UI tab selalu hadir secara default |
| [Alat pivot](/docs/id-id/studio/pivot-tools) | Model tab | no change |
| [Alat penyelarasan](/docs/id-id/studio/align-tool) | Model tab | Aplikasi studio ⟩ Jendela menu ⟩ 3D \> Sesuaikan |
| [Generator Bahan](/docs/id-id/studio/material-generator) | Rumah atau Model tab ⟩ Pemilih dropdown bahan ⟩ Menghasilkan | Aplikasi studio ⟩ Jendela menu ⟩ 3D \> Pembangkit Bahan |
| [Alat model solid](/docs/id-id/parts/solid-modeling) | Model tab | no change |
| [Pemilihan batasan / penyisipan](/docs/id-id/physics#constraints) | Model tab | no change |
| Tampilkan sambungan tutup | Model tab | Aplikasi studio ⟩ Lihat menu ⟩ Tampilkan Celah |
| Tampilkan Detail Batasan toggle | Model tab | Aplikasi studio ⟩ Lihat menu ⟩ Tampilkan Detail Kekuatan Terbatas |
| [Pilih/masukkan efek](/docs/id-id/effects) | Model tab | no change |
| Memunculkan inserter | Model tab | — Gunakan metode penyisipan standar untuk menyisipkan [SpawnLocation](/docs/id-id/reference/engine/classes/SpawnLocation) |
| Lanjutan ⟩ Sisipkan Objek | Model tab | Aplikasi studio ⟩ Jendela menu ⟩ Masukkan Objek |
| Model Lanjutan ⟩ | Model tab | — Gunakan menu File ≥ Impor 3D |
| Layanan Lanjutan ⟩ | Model tab | Klik kanan di atas layanan yang terlihat di [Explorer](/docs/id-id/studio/explorer) dan pilih Tampilkan Layanan... dari menu konteks |
| Kelompok Tabrakan Lanjutan | Model tab | Aplikasi studio ⟩ Jendela menu ⟩ 3D \> Grup Kolisi |
| Lanjutan ⟩ Jalankan Skrip | Model tab | Aplikasi studio ⟩ Jendela menu ⟩ Skrip \> Jalankan skrip |
| Skrip Lanjutan, Skrip Lokal, Skrip Modul | Model tab | Rumah atau Skrip tab \> Skrip pilih/masukkan |
### Avatar dan animasi
| Aksi/Alat | Alur Kerja Lama(s) | Alur Kerja Baru(s) |
| --- | --- | --- |
| [Importasi 3D](/docs/id-id/art/modeling/3d-importer) | Rumah atau Avatar tab | Aplikasi studio ⟩ File menu ⟩ Impor 3D |
| [Editor Animasi](/docs/id-id/animation/editor) | Avatar atau Tampilkan tab | 🄐 Avatar tab \> Animasi 🄑 Aplikasi Studio \> Jendela menu \> Avatar \> Animasi |
| [Alat Pemasangan Aksesori](/docs/id-id/art/accessories/accessory-fitting-tool) | Avatar tab | 🄐 Avatar tab \> Aksesori 🄑 Aplikasi Studio \> Jendela menu \> Avatar \> Aksesori |
| [Pembangun Rig](/docs/id-id/studio/rig-builder) | Avatar tab | Rumah atau Avatar tab \> Karakter |
| [Pengaturan Avatar](/docs/id-id/avatar-setup) | Avatar tab | 🄐 Avatar tab \> Konfigurasi 🄑 aplikasi Studio \> Jendela menu \> Avatar \> Konfigurasi |
### Pengujian dan visualisasi
| Aksi/Alat | Alur Kerja Lama(s) | Alur Kerja Baru(s) |
| --- | --- | --- |
| Mode pengujian permainan | Rumah atau Tes tab | Sisi kiri dari bar mezzanine \>\> Pemilih mode |
| Tombol pengujian playtest | Rumah atau Tes tab, atau sisi kiri dari bar mezzanine | Sisi kiri dari bar mezzane |
| [Client/server beralih](/docs/id-id/studio/testing-modes#toggle-clientserver) | Rumah atau Tes tab | Sisi kiri dari bar mezzane |
| [Jeda/lanjutkan fisika](/docs/id-id/studio/testing-modes#pause-and-resume-physics) | Uji tab | Opsi muncul secara kontekstual di sisi kiri bar mezzanine saat melakukan pengujian permainan |
| [Simulasi multi\-klien](/docs/id-id/studio/testing-modes#multi-client-simulation) | Uji tab | Sisi kiri dari bar mezzanine ⟩ Pemilih mode ⟩ Server \& Klien |
| [Emulator Perangkat](/docs/id-id/studio/testing-modes#device-emulation) | Uji tab | Aplikasi studio ⟩ Lihat menu ⟩ Emulator Perangkat |
| [Pemulator Kontroler](/docs/id-id/studio/testing-modes#controller-emulation) | Uji tab | — Dapat ditambahkan kembali ke tab khusus melalui Tambah Alat \> Kontroler |
| [Emulator Pemain](/docs/id-id/studio/testing-modes#player-emulation) | Uji tab | Aplikasi studio ⟩ Lihat menu ⟩ Emulator Pemutar |
| Lihat Pemilih | Lihat tab | Aplikasi studio ⟩ Lihat menu ⟩ Tampilkan Pemilih Pandangan |
| Visualisasi grid | Lihat tab | Aplikasi studio ⟩ Lihat menu ⟩ Tampilkan Grid \& Tampilkan Material Grid |
| Rendering Wireframe | Lihat tab | Aplikasi studio ⟩ Lihat menu ⟩ Tampilkan Rendering Wireframe |
| Keterlihatan UI | Lihat tab | Aplikasi studio ⟩ Lihat menu ⟩ Tampilkan UI |
| [Arah Angin](/docs/id-id/environment/global-wind#wind-direction-widget) | Lihat tab | Aplikasi studio ⟩ Lihat menu ⟩ Tampilkan Arah Angin |
| [Gaya Pemilihan](/docs/id-id/studio/ui-overview#object-selection) | Lihat tab | Pengaturan Studio \> Pilihan \> Opsi dalam Visualisasi Pilihan |
| Pengujian Tim | Rumah tab | — Dapat ditambahkan kembali ke tab khusus melalui Tambah Alat \> Tes Tim |
| Matikan | Uji tab | Aplikasi studio ⟩ Lihat menu ⟩ Mute |
### Skrip dan debugging
| Aksi/Alat | Alur Kerja Lama(s) | Alur Kerja Baru(s) |
| --- | --- | --- |
| Kembali, Fwd | Skrip tab | no change |
| Temukan/Ganti (dasar) | Skrip tab | Skrip tab \> ≥ Temukan tombol popup \> ≥ Temukan… |
| Temukan/Ganti (lanjutan) | Skrip tab | 🄐 Skrip tab \> Temukan tombol popup \> Temukan Semua 🄑 aplikasi Studio \> Menu jendela \> Skrip \> Temukan Semua / Ganti Semua |
| Pergi ke Baris | Skrip tab | no change |
| Gantikan | Skrip tab | — Dapat ditambahkan kembali ke tab khusus melalui Tambah Alat \> Ganti |
| Pilih | Skrip tab | — Tugas dapat dicapai melalui klik kanan ⟩ Pilih Semua ( CtrlA / ⌘A ) |
| Pemilihan Format | Skrip tab | Tab Skrip ⟩ Format |
| Langkah Masuk, Langkah Melampaui, Langkah Keluar | Skrip tab | Tombol muncul secara kontekstual di sisi kiri bar mezzanine saat titik istirahat terkena |
| Tindakan skrip lain | Skrip tab | — Lihat [di sini](/docs/id-id/studio/script-tab#other-actions) untuk setara pintas |
| Analisis Skrip | Lihat tab | 🄐 Aplikasi Studio \> Jendela menu \> Skrip \> Analisis 🄑 Skrip tab \> Analisis |
| Performance | Lihat tab | Aplikasi studio ⟩ Jendela menu ⟩ Kinerja \> Kinerja |
| Jadwal Tugas | Lihat tab | Aplikasi studio ⟩ Jendela menu ⟩ Skrip \> Jadwal tugas |
| Performa Skrip | Lihat tab | 🄐 Aplikasi Studio \> Jendela menu \> Skrip \> Kinerja 🄑 Skrip tab \> Kinerja |
| Tumpukan Panggilan | Lihat tab | 🄐 Aplikasi Studio \> Jendela menu \> Debug \> Tumpukan Panggilan 🄑 Skrip tab \> Tumpukan Panggilan |
| Titik patah | Lihat tab | 🄐 Aplikasi Studio \> Jendela menu \> Debug \> Titik pemutusan 🄑 Skrip tab \> Titik pemutusan |
| Menonton | Lihat tab | 🄐 Aplikasi Studio \> Jendela menu \> Debug \> Tonton 🄑 Skrip tab \> Tonton |
| Statistik, Render, Fisika, Jaringan, Ringkasan | Lihat tab | Aplikasi studio ⟩ Jendela menu ⟩ Kinerja |
### Lainnya
| Aksi/Alat | Alur Kerja Lama(s) | Alur Kerja Baru(s) |
| --- | --- | --- |
| [Sejarah Aktivitas](/docs/id-id/projects/activity-history) | Lihat tab | Aplikasi studio ⟩ Jendela menu ⟩ Histori Aktivitas |
| Pembuatan Tim | Lihat tab | Aplikasi studio ⟩ Jendela menu ⟩ Kolaborasi \> \> Pembuatan Tim |
| Captur Layar | Lihat tab | Aplikasi studio ⟩ Lihat menu ⟩ Screenshot |
| Catatan Video | Lihat tab | removed |
| Tukar Jendela | Lihat tab | removed |
| 26 |
https://create.roblox.com/docs/id-id/studio/align-tool
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Alat Penyelarasan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/align-tool).
Alat Selarikan memungkinkan Anda menyelarikan objek atau kelompok objek di sepanjang X , Y , atau Z sumbu.Anda dapat mengaksesnya dari tab [Model](/docs/id-id/studio/model-tab).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Align-Tool.png' alt='Studio's Model tab with the Align Tool highlighted.' title='' width='660' height='' />Manfaat utama termasuk:
* Menyesuaikan pusat atau ujung dari beberapa objek dalam satu tindakan.
* Menyelaraskan seluruh [Models](/docs/id-id/reference/engine/classes/Model) atau bagian di dalamnya relatif terhadap bagian lain, semua sambil menjaga model utuh.
* Memprediksi secara dinamis titik alineasi sebelum menyetujui.
## [Mode](#mode)
Anda dapat mengatur mode alineasi ke Min , Tengah , atau Maks .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/align-tool/Icon-Min.png' alt='The Min icon in the toolbar.' title='' width='80' height='' />
*Menit*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/align-tool/Icon-Center.png' alt='The Center icon in the toolbar.' title='' width='80' height='' />
*Tengah*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/align-tool/Icon-Max.png' alt='The Max icon in the toolbar.' title='' width='80' height='' />
*Maksimal*
Minimal
Tengah
Maksimum
<img src='https://prod.docsiteassets.roblox.com/assets/studio/align-tool/Mode-Min.jpg' alt='An angled side view of a small red cube, large blue cube, and a small purple cube that are aligned with the Min button on the world Z axis. A translucent orange rectangle represents where the objects align in context to each other.' title='' width='720' height='405' />
## [Selaras Dalam](#selaras-dalam)
Opsi Dunia atau Lokal menentukan koordinat relatif mana untuk disesuaikan.Ini terutama berguna untuk menyelaraskan bagian yang tidak berbagi orientasi atau rotasi yang sama.
Kotak centang X , Y , dan Z memungkinkan Anda memilih sumbu mana untuk disesuaikan.Perhatikan bahwa Anda dapat memilih beberapa sumbu dalam satu operasi alineasi.
Sebelum Penyesuaian
Maks \| Dunia Z
Maks \| Lokal Z
<img src='https://prod.docsiteassets.roblox.com/assets/studio/align-tool/Align-In-Before.jpg' alt='An angled side view of a small red cube, large blue cube, and a small purple cube that are unaligned.' title='' width='720' height='405' />
## [Relatif Terhadap](#relatif-terhadap)
Operasi penyelarasan dapat relatif terhadap batas pilihan atau objek aktif .
### [Batas Pilihan](#batas-pilihan)
Batas Pilihan mengatur objek yang dipilih relatif terhadap kotak batas di sekitar mereka.
Sebelum Penyesuaian
Min \| Dunia X
Maks \| Dunia X
<img src='https://prod.docsiteassets.roblox.com/assets/studio/align-tool/Relative-To-Selection-Bounds-Before.jpg' alt='An angled side view of a small red cube, large blue cube, and a small purple cube that are unaligned. A translucent red rectangle represents where the objects' collective bounding box.' title='' width='720' height='405' />
### [Objek Aktif](#objek-aktif)
Objek Aktif menyesuaikan objek relatif terhadap objek terakhir yang dipilih .Objek ini ditampilkan dalam warna oranye dan tidak akan bergerak selama operasi.Saat bagian dipilih, Anda dapat beralih objek aktif dengan mengklik objek yang berbeda.
Sebelum Penyesuaian
Min \| Dunia X
Maks \| Dunia X
<img src='https://prod.docsiteassets.roblox.com/assets/studio/align-tool/Relative-To-Active-Object-Before.jpg' alt='An angled side view of a small red cube, large blue cube, and a small purple cube that are unaligned. The large blue cube has a yellow outline to represent that it's the active object.' title='' width='720' height='405' />
| 27 |
https://create.roblox.com/docs/id-id/studio/pivot-tools
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Alat berputar
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/pivot-tools).
Alat pivot dan properti terkait memberi Anda kontrol penuh atas titik di sekitar mana objek berputar dan diterjemahkan.
## [Alat Studio Interaktif](#alat-studio-interaktif)
Alat Studio interaktif berlokasi di tab [Model](/docs/id-id/studio/model-tab).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Pivot-Tools.png' alt='Studio's Model tab with the Pivot Tools section highlighted.' title='' width='768' height='' />
### [Edit Pivot](#edit-pivot)
Alat Edit Pivot memungkinkan Anda untuk memindahkan atau memutar titik pivot dari [bagian](/docs/id-id/parts) atau [model](/docs/id-id/parts/models).Setelah ditetapkan, rotasi dan skala terjadi di sekitar titik pivot.Untuk informasi lebih lanjut, lihat [Mengatur Bagian Utama](/docs/id-id/parts/models#setting-a-primary-part) .
Diagram berikut menunjukkan lokasi pivot contoh dalam kaitannya dengan batas objek.
Tengah
Sudut
Di luar Batas Objek
<img src='https://prod.docsiteassets.roblox.com/assets/studio/pivot-tools/Edit-Pivot-Center-A.jpg' alt='A blue cube with its pivot point set in the center of the cube. A green circle represents the object's rotation in relation to its pivot point.' title='' width='720' height='405' />Ketika Anda memutar sumbu model , kotak batas model juga berputar.
Orientasi \= (0, 90, 0\)
Orientasi \= (0, 135, 0\)
Orientasi \= (0, 180, 0\)
<img src='https://prod.docsiteassets.roblox.com/assets/studio/pivot-tools/Edit-Pivot-Model-A.jpg' alt='A model of a purple, blue, and red block with its pivot point set on a the edge of the model's bounding box. A green circle represents the object's rotation in relation to its pivot point.' title='' width='720' height='405' />Anda dapat menentukan [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) untuk model, yang merupakan [BasePart](/docs/id-id/reference/engine/classes/BasePart) dalam model yang dapat Anda gunakan sebagai dasar posisi. Dalam hal titik pivot:
2. Ketika Anda menugaskan [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) ke model, perubahan pivot yang ada ke titik pivot dari [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) .Jika Anda kemudian menghapus/menghapus [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) , titik pivot diatur ulang ke pusat
2\> dari kotak batas model.: Jika Anda menghapus dari model, titik pivot tetap berada di lokasi yang sama dan tidak melakukan kembali ke posisi sebelumnya.Ini mencegah "loncat" tiba\-tiba jika Anda menghapus bagian mana pun dari model. 6\>
Titik Pivot Awal
A. Bagian Utama Ditugaskan
B. Bagian Utama Dihapus
<img src='https://prod.docsiteassets.roblox.com/assets/studio/pivot-tools/PrimaryPart-1.jpg' alt='' title='' width='720' height='405' />
### [Ambil](#ambil)
Kotak centang Snap menyala atau mati apakah titik pivot tertangkap ke hotspot seperti sudut, sisi, atau pusat saat Anda memindahkannya dengan alat Edit Pivot .Ketika geser diaktifkan, hotspot ditampilkan sebagai titik magenta kecil.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/pivot-tools/Hotspots-Part.jpg' alt='' title='' width='100%' height='' />
*Hotspot pada bagian*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/pivot-tools/Hotspots-Model.jpg' alt='' title='' width='100%' height='' />
*Hotspot pada model*
### [Setel ulang](#setel-ulang)
Tombol Reset memindahkan titik pivot ke bagian tengah dari kotak batas objek atau model.Operasi ini berguna setelah Anda mengubah komposisi model dan ingin menempatkan titik pivotnya di pusat kotak batas barunya.
## [Properti rotasi](#properti-rotasi)
Selain alat interaktif, nilai pivot dapat ditetapkan langsung di jendela [Properti](/docs/id-id/studio/properties).
| Propinsi | Deskripsi |
| --- | --- |
| Posisi Asal | Lokasi dunia saat ini dari objek berdasarkan titik pivotnya daripada kotak batasnya. Berguna untuk menetapkan lokasi tepat dari [Model](/docs/id-id/reference/engine/classes/Model) . |
| Orientasi Asal | Orientasi saat ini dari objek yang berbasis di sekitar titik pivotnya daripada kotak batasnya. |
| Posisi Offset Pivot | Lokasi tepat dari pivot terhadap objek.¹ |
| Orientasi Penyesuaian Pivot | Orientasi pivot tepat.¹ |
| Posisi Pivot Dunia | Lokasi dunia yang tepat dari pivot untuk [Models](/docs/id-id/reference/engine/classes/Model) tanpa [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) .Jika sebuah [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) diatur, model akan menggunakan Posisi Offset Pivot karena pivot menjadi relatif terhadap bagian itu.¹ |
| Orientasi Pivot Dunia | Orientasi dunia yang tepat untuk [Models](/docs/id-id/reference/engine/classes/Model) tanpa [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) .Jika sebuah [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) atur, model akan menggunakan Pivot Offset Orientasi karena pivot menjadi relatif terhadap bagian itu.¹ |
*1 Mengubah properti ini tidak akan memindahkan atau memutar objek.*
## [Manipulasi pivot di skrip](#manipulasi-pivot-di-skrip)
Selain alat Studio, titik pivot dapat diakses dan dimanipulasi dalam skrip.
| Fungsi atau Properti | Deskripsi |
| --- | --- |
| [GetPivot()](/docs/id-id/reference/engine/classes/PVInstance#GetPivot) | Mengueri lokasi dunia saat ini dari titik pivot objek sebagai [CFrame](/docs/id-id/reference/engine/datatypes/CFrame).Ini mengembalikan posisi objek di ruang 3D terlepas dari apakah itu bagian individu atau [Model](/docs/id-id/reference/engine/classes/Model) . |
| [PivotTo()](/docs/id-id/reference/engine/classes/PVInstance#PivotTo) | Pindahkan objek sehingga titik pivotnya akan terletak di [CFrame](/docs/id-id/reference/engine/datatypes/CFrame) yang ditentukan.Ini memungkinkan gerakan objek yang seragam dari kedua bagian dan model individu. |
| [BasePart.PivotOffset](/docs/id-id/reference/engine/classes/BasePart#PivotOffset) | The [CFrame](/docs/id-id/reference/engine/datatypes/CFrame) yang menentukan offset pivot; efektif offset pivot dari [CFrame](/docs/id-id/reference/engine/datatypes/CFrame) dari [BasePart](/docs/id-id/reference/engine/classes/BasePart) .² |
| [Model.WorldPivot](/docs/id-id/reference/engine/classes/BasePart#PivotOffset) | Untuk [Models](/docs/id-id/reference/engine/classes/Model) tanpa [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) , [CFrame](/docs/id-id/reference/engine/datatypes/CFrame) yang menentukan titik pivot model di ruang dunia.Jika [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) diatur, model akan menggunakan [BasePart.PivotOffset](/docs/id-id/reference/engine/classes/BasePart#PivotOffset) karena pivot menjadi relatif terhadap bagian itu.² |
*2 Mengubah properti ini tidak akan memindahkan atau memutar objek.*
| 28 |
https://create.roblox.com/docs/id-id/studio/terrain-editor
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Editor Tanah
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/terrain-editor).
Editor Tanah , yang dapat diakses dari tab [Rumah](/docs/id-id/studio/home-tab) di bilah alat, memungkinkan Anda menghasilkan dan memanipulasi [tanah lingkungan](/docs/id-id/parts/terrain) melalui set alat [Buat](#create-tab) dan [Edit](#edit-tab).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Terrain-Editor.png' alt='Terrain Editor indicated in Home tab' title='' width='716' height='' />Untuk instruksi terperinci tentang bekerja dengan medan, lihat panduan [Medan](/docs/id-id/parts/terrain).
## [Buat tab](#buat-tab)
Tab Buat termasuk [Impor](#import), [Hasilkan](#generate), dan [Bersihkan](#clear) alat.
### [Importasi](#importasi)
Alat Impor mem导入 [peta ketinggian](/docs/id-id/parts/terrain#heightmaps-and-colormaps) dan opsional [peta warna](/docs/id-id/parts/terrain#heightmaps-and-colormaps) dan menerapkannya ke wilayah yang dipilih
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Create-Tab-Import.png' alt='Import tool indicated in Create tab of Terrain Editor' title='' width='360' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Terrain-Heightmap.png' alt='Example heightmap image' title='' width='100%' height='' />
*Peta Ketinggian*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Terrain-Colormap.png' alt='Example colormap image' title='' width='100%' height='' />
*Peta Warna*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Terrain-Colormap-Result.jpg' alt='Terrain generated from the example heightmap and colormap' title='' width='100%' height='' />
*Tanah yang dihasilkan*
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Import-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Import-Tool.mp4)
| Pengaturan pemilihan | |
| --- | --- |
| Ukuran, posisi, dan opsi geser seperti yang dinyatakan untuk alat [Pilih](#select). | |
| Pengaturan Peta Ketinggian | |
| --- | --- |
| Peta Ketinggian | Impor peta ketinggian dari file gambar lokal. |
| Peta Warna | Impor peta warna dari file gambar lokal untuk digunakan bersama peta ketinggian. |
| Bahan Dasar | Mengidentifikasi satu bahan konsisten untuk diterapkan di seluruh wilayah yang dihasilkan. Ini digantikan oleh bahan berdasarkan peta warna, jika diimpor. |
### [Hasilkan](#hasilkan)
Alat Menghasilkan secara prosedural menghasilkan tanah dalam wilayah yang dipilih.Ini berguna jika Anda ingin membuat peta besar dan kemudian menyempurnakan rincian medan menggunakan alat tab [Edit](#edit-tab).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Create-Tab-Generate.png' alt='Generate tool indicated in Create tab of Terrain Editor' title='' width='360' height='' />[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Generate-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Generate-Tool.mp4)
| Pengaturan pemilihan | |
| --- | --- |
| Ukuran, posisi, dan opsi geser seperti yang dinyatakan untuk alat [Pilih](#select). | |
| Pengaturan bioma | |
| --- | --- |
| Bioma | Memasukkan bioma yang dipilih dalam medan yang dihasilkan. |
| Mencampur | Menyesuaikan bagaimana bioma saling bercampur, dengan nilai yang lebih tinggi sedikit lebih halus. |
| Gua | Memasukkan gua di medan yang dihasilkan. |
| Ukuran Bioma | Tetapkan ukuran bioma dalam ukuran tanah keseluruhan. |
| Tanaman Biji | Angka yang dihasilkan oleh Studio untuk menentukan bentuk medan.Saat Anda mengubah nomor ini, Studio menghasilkan medan baru dengan pengaturan yang sama. |
### [Jelas](#jelas)
Alat Jelas menunjukkan tombol yang membersihkan semua medan di seluruh tempat.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Create-Tab-Clear.png' alt='Clear tool indicated in Create tab of Terrain Editor' title='' width='360' height='' />
## [Buka tab Edit](#buka-tab-edit)
Tab Edit termasuk [Pilih](#select) , [Transformasi](#transform) , [Isi](#fill) , [Tingkat Laut](#sea-level) , [Menggambar](#draw) , [Memahat](#sculpt) , [Haluskan](#smooth) , [Melukis](#paint) , dan [Meratakan](#flatten) alat.
### [Pilih](#pilih)
Alat Pilih adalah alat universal untuk memilih wilayah berbentuk persegi di medan.Dengan alat diaktifkan, pilih wilayah dengan mengklik dan seret di jendela 3D, reposisikan dengan penyeret pindahkan , dan ubah ukurannya dengan penangan skala .Alternatifnya, masukkan nilai ke dalam input X / Y / Z dari alat untuk menetapkan posisi dan ukuran tertentu.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Select.png' alt='Select tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />
| Pengaturan pemilihan | |
| --- | --- |
| Ukuran | Mengatur nilai spesifik X / Y / Z untuk ukuran seleksi, dalam stud. |
| Posisi | Mengatur nilai spesifik X / Y / Z untuk posisi seleksi. |
| Terapkan ke Voxels | Memotret batas pilihan ke vokel terdekat. |
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Select-Region-Labeled.jpg' alt='Move draggers and scale handles on a selected region' title='' width='800' height='' />
*Gerakkan penyeret dan tangan skala pada wilayah yang dipilih*
Studio juga mendukung pintasan keyboard dan mouse berikut, asumsi alat Pilih aktif dan tidak ada yang dipilih dalam hierarki [Explorer](/docs/id-id/studio/explorer).
| Jendela | Makan Mac | Tindakan |
| --- | --- | --- |
| CtrlC | ⌘C | Salin medan dalam wilayah yang dipilih ke clipboard. |
| CtrlV | ⌘V | Tempelkan tanah yang telah disalin ke bilah klip dan bertukar ke alat [Transformasi](#transform) sehingga tanah baru dapat diubah. |
| CtrlX | ⌘X | Potong tanah di dalam wilayah yang dipilih ke clipboard. |
| CtrlD | ⌘D | Duplikasi tanah di dalam wilayah yang dipilih dan bertukar ke alat [Transformasi](#transform) sehingga tanah baru dapat diubah. |
| Delete | Delete | Hapus medan di dalam wilayah yang dipilih. |
| Shift | Shift | Saat dipegang saat menyeret skala apa pun , skala wilayah secara proporsional di semua sumbu lainnya. |
| Ctrl | ⌘ | Saat dipegang saat menyeret skala apa pun , skala wilayah sama di kedua arah positif dan negatif di sepanjang sumbu itu. |
### [Transformasi](#transformasi)
Alat Transformasi mengubah seluruh [dipilih](#select) wilayah ke posisi, ukuran, atau orientasi baru.Dengan alat diaktifkan, ubah wilayah yang dipilih dengan penyeret pindahkan , cincin putar , dan tangan skala .Alternatifnya, masukkan nilai ke dalam input X / Y / Z dari alat untuk menetapkan posisi, ukuran, dan rotasi tertentu.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Transform.png' alt='Transform tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />
| Transformasi pengaturan | |
| --- | --- |
| Ukuran | Mengatur nilai spesifik X / Y / Z untuk ukuran seleksi dalam stud. |
| Posisi | Mengatur nilai spesifik X / Y / Z untuk posisi seleksi. |
| Rotasi | Mengatur nilai spesifik X / Y / Z untuk rotasi seleksi dalam derajat. |
| Gabung Kosong | Saat diaktifkan, voksels udara dalam seleksi akan menghapus voksels yang ada di tujuan. |
| Edit Langsung | Saat diaktifkan, medan terus diperbarui saat diterjemahkan.Untuk melihat hanya pratinjau wireframe transformasi, nonaktifkan mode edit langsung dan kemudian, saat mengubah, tekan Enter / Return atau klik tombol Terapkan untuk menerapkan perubahan. |
| Terapkan ke Voxels | Memotret batas pilihan ke vokel terdekat. |
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Transform-Region-Labeled.jpg' alt='Move draggers, rotate rings, and scale handles on a selected region' title='' width='780' height='' />
*Gerakkan penyeret, putar cincin, dan tangani skala di wilayah yang dipilih*
Sebelum memutar wilayah dengan cincin visual memutar , periksa pengaturan [pemotongan rotasi](/docs/id-id/studio/model-tab#transform-snapping) di tab [Model](/docs/id-id/studio/model-tab) Studio.Nonaktifkan pemotongan rotasi sepenuhnya untuk rotasi bebas bentuk.
Mirip dengan memilih wilayah, menahan saat menyeret skala apa pun skala skala skala proporsional di semua sumbu lain, dan menahan atau saat menyeret skala wilayah sama di kedua arah positif dan negatif di sepanjang sumbu itu.
### [Isi](#isi)
Alat Isi mengisi seluruh [terpilih](#select) wilayah dengan bahan tertentu, atau menggantikan semua bahan di dalam wilayah dengan bahan lain.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Fill.png' alt='Fill tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />
| Pengaturan pemilihan | |
| --- | --- |
| Ukuran, posisi, dan opsi geser seperti yang dinyatakan untuk alat [Pilih](#select). | |
| Pengaturan bahan | |
| --- | --- |
| Mode Isi | Mengalihkan alat antara Isi dan Ganti mode. |
| Bahan Sumber | Di mode Isi , bahan isi yang diinginkan. Di mode Ganti , bahan yang akan diganti. |
| Bahan Target | Dalam mode Ganti , materi untuk menggantikan sumber materi dengan. |
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Fill-Region.jpg' alt='Region filled with Salt material' title='' width='780' height='' />
*Wilayah yang dipilih dipenuhi dengan materi Garam*
### [Tingkat level](#tingkat-level)
Alat Tingkat Laut memungkinkan Anda untuk membuat tingkat air yang konsisten atau menghapus semua air di dalam wilayah.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Sea-Level.png' alt='Sea Level tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Sea-Level-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Sea-Level-Tool.mp4)
| Pengaturan tingkat laut | |
| --- | --- |
| Ukuran | Mengatur nilai spesifik X / Y / Z untuk ukuran seleksi dalam stud. |
| Posisi | Mengatur nilai spesifik X / Y / Z untuk posisi seleksi. |
| Terapkan ke Voxels | Memotret batas pilihan ke vokel terdekat. |
### [Menggambar](#menggambar)
Alat Menggambar menambahkan atau mengurangi medan menggunakan sikat.Alat ini berfungsi dalam mode ganda di mana menahan Ctrl atau ⌘ beralih ke mode "pengurangan" bukan mode "tambahan" default.Selain itu, menahan Shift sementara mengaktifkan alat [Mulus](#smooth).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Draw.png' alt='Draw tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Draw-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Draw-Tool.mp4)
| Pengaturan sikat | |
| --- | --- |
| Mode Sikat | Mengubah alat antara Tambahkan dan Kurangi mode. Juga diaktifkan dengan menahan Ctrl atau ⌘ . |
| Bentuk Sikat | Atur bentuk sikat ke bola , kotak , atau silinder . Brush shape icons in the Terrain Editor |
| Ukuran Sikat | Mengatur ukuran sikat dari 1 hingga 64\.Jika Anda memilih bentuk sikat dari kotak atau silinder , slider/输入 Tinggi juga muncul untuk menyesuaikan ketinggian sikat secara proporsional atau independen dari ukuran dasar. |
| Posisi Pivot | Atur titik pivot vertikal dari sikat ke bagian bawah, tengah, atau atas tempat sikat terhubung dengan medan yang ada. |
| Memasangkan | Apakah klik otomatis dimatikan atau ke vokel terdekat. |
| Kunci Pesawat | Aktifkan apakah untuk mengaktifkan pesawat visual yang dikunci oleh sikat.Di mode Otomatis , pesawat miring dan berputar dengan kamera.Di mode Manual , opsi Edit Pesawat muncul, memungkinkan Anda menetapkan posisi/orientasi tertentu melalui penggerak visual atau X / Y / Z input. |
| Abaikan Air | Mengabaikan air saat menambahkan atau mengurangi medan. |
| Abaikan Bagian | Mengabaikan [bagian](/docs/id-id/parts) dalam hal penempatan sikat saat memindahkan pointer mouse di permukaan bagian. |
| Pengaturan bahan | |
| --- | --- |
| Bahan Otomatis | Menggunakan material medan yang sama di sekitar sikat saat menambahkan medan baru. |
| Bahan Sumber | Tetapkan [material](/docs/id-id/parts/terrain#terrain-materials) untuk Tambahkan mode. |
### [Memahat](#memahat)
Alat Memahat menambahkan atau mengurangi medan menggunakan sikat.Tidak seperti alat [Draw](#draw) , alat ini memiliki slider / input kekuatan untuk memungkinkan manipulasi wilayah yang lebih lembut.Alat ini berfungsi dalam mode ganda di mana menahan Ctrl atau ⌘ menyalakan mode "pengurang" alih\-alih mode "tambah" default, dan menahan Shift sementara mengaktifkan alat [Muluskan](#smooth) .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Sculpt.png' alt='Sculpt tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Sculpt-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Sculpt-Tool.mp4)
| Pilihan | Deskripsi |
| --- | --- |
| Mode Sikat | Mengubah alat antara Tambahkan dan Kurangi mode. Juga diaktifkan dengan menahan Ctrl atau ⌘ . |
| Bentuk Sikat | Atur bentuk sikat ke bola , kotak , atau silinder . Brush shape icons in the Terrain Editor |
| Ukuran Sikat | Mengatur ukuran sikat dari 1 hingga 64\.Jika Anda memilih bentuk sikat dari kotak atau silinder , slider/输入 Tinggi juga muncul untuk menyesuaikan ketinggian sikat secara proporsional atau independen dari ukuran dasar. |
| Kekuatan | Mengatur kekuatan sikat dari 0,1 hingga 1\. |
| Kunci Pesawat | Aktifkan apakah untuk mengaktifkan pesawat visual yang dikunci oleh sikat.Di mode Otomatis , pesawat miring dan berputar dengan kamera.Di mode Manual , opsi Edit Pesawat muncul, memungkinkan Anda menetapkan posisi/orientasi tertentu melalui penggerak visual atau X / Y / Z input. |
| Abaikan Air | Mengabaikan air saat menambahkan atau mengurangi medan. |
| Abaikan Bagian | Mengabaikan [bagian](/docs/id-id/parts) dalam hal penempatan sikat saat memindahkan pointer mouse di permukaan bagian. |
| Bahan Otomatis | Menggunakan material medan yang sama di sekitar sikat saat menambahkan medan baru. |
| Bahan Sumber | Tetapkan [material](/docs/id-id/parts/terrain#terrain-materials) untuk Tambahkan mode. |
### [Halus](#halus)
Alat Mulus membuat perbatasan tiba\-tiba menjadi halus di medan menggunakan sikat.Alat ini dapat digunakan dalam mode berdiri sendiri, atau Anda dapat mengaktifkannya dengan menahan Shift saat menggunakan alat [Menggambar](#draw) atau [Memahat](#sculpt) .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Smooth.png' alt='Smooth tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Smooth-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Smooth-Tool.mp4)
| Pilihan | Deskripsi |
| --- | --- |
| Bentuk Sikat | Atur bentuk sikat ke bola , kotak , atau silinder . Brush shape icons in the Terrain Editor |
| Ukuran Sikat | Mengatur ukuran sikat dari 1 hingga 64\.Jika Anda memilih bentuk sikat dari kotak atau silinder , slider/输入 Tinggi juga muncul untuk menyesuaikan ketinggian sikat secara proporsional atau independen dari ukuran dasar. |
| Kekuatan | Mengatur kekuatan sikat dari 0,1 hingga 1\. |
| Posisi Pivot | Atur titik pivot vertikal dari sikat ke bagian bawah, tengah, atau atas tempat sikat terhubung dengan medan yang ada. |
| Memasangkan | Apakah klik otomatis dimatikan atau ke vokel terdekat. |
| Kunci Pesawat | Aktifkan apakah untuk mengaktifkan pesawat visual yang dikunci oleh sikat.Di mode Otomatis , pesawat miring dan berputar dengan kamera.Di mode Manual , opsi Edit Pesawat muncul, memungkinkan Anda menetapkan posisi/orientasi tertentu melalui penggerak visual atau X / Y / Z input. |
| Abaikan Air | Mengabaikan air saat merapikan medan. |
| Abaikan Bagian | Mengabaikan [bagian](/docs/id-id/parts) dalam hal penempatan sikat saat memindahkan pointer mouse di permukaan bagian. |
### [Lukis](#lukis)
Alat Lukis menggunakan sikat, melukis wilayah [materi](/docs/id-id/parts/terrain#terrain-materials) atas materi yang ada atau menggantikan satu materi dengan materi lain.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Paint.png' alt='Paint tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Paint-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Paint-Tool.mp4)
| Pilihan | Deskripsi |
| --- | --- |
| Bentuk Sikat | Atur bentuk sikat ke bola , kotak , atau silinder . Brush shape icons in the Terrain Editor |
| Ukuran Sikat | Mengatur ukuran sikat dari 1 hingga 64\.Jika Anda memilih bentuk sikat dari kotak atau silinder , slider/输入 Tinggi juga muncul untuk menyesuaikan ketinggian sikat secara proporsional atau independen dari ukuran dasar. |
| Posisi Pivot | Atur titik pivot vertikal dari sikat ke bagian bawah, tengah, atau atas tempat sikat terhubung dengan medan yang ada. |
| Memasangkan | Apakah klik otomatis dimatikan atau ke vokel terdekat. |
| Kunci Pesawat | Aktifkan apakah untuk mengaktifkan pesawat visual yang dikunci oleh sikat.Di mode Otomatis , pesawat miring dan berputar dengan kamera.Di mode Manual , opsi Edit Pesawat muncul, memungkinkan Anda menetapkan posisi/orientasi tertentu melalui penggerak visual atau X / Y / Z input. |
| Abaikan Air | Mengabaikan air saat meratakan tanah. |
| Abaikan Bagian | Mengabaikan [bagian](/docs/id-id/parts) dalam hal penempatan sikat saat memindahkan pointer mouse di permukaan bagian. |
| Mode Bahan | Mengalihkan alat antara Lukis dan Ganti mode.Di mode Lukis , pilih bahan lukisan yang diinginkan dari ubin pemilih alat.Di Mode Ganti , pilih kedua bahan sumber untuk diganti dan bahan target untuk menggantikannya. |
### [Memperbaiki](#memperbaiki)
Alat Memperbaiki memperbaiki medan ke tingkat konsisten di sepanjang pesawat yang diceritakan secara visual.Secara default, alat menurunkan medan di atas pesawat dan meningkatkan medan di bawah ke pesawat, tetapi Anda dapat memilih untuk menurunkan secara selektif atau angkat melalui opsi Flatten Mode alat.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Flatten.png' alt='Flatten tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Flatten-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Flatten-Tool.mp4)
| Pilihan | Deskripsi |
| --- | --- |
| Bentuk Sikat | Atur bentuk sikat ke bola , kotak , atau silinder . Brush shape icons in the Terrain Editor |
| Mode Memperkecilkan | Terusikan ke Flat ¹ meratakan tanah di atas pesawat. Tumbuh ke Flat ² mengisi medan di bawah pesawat. Flatten Semua ³ menghapus medan di atas pesawat dan mengisi medan di bawah pesawat.Flatten Mode icons in the Terrain Editor |
| Ukuran Sikat | Mengatur ukuran sikat dari 1 hingga 64\.Jika Anda memilih bentuk sikat dari kotak atau silinder , slider/输入 Tinggi juga muncul untuk menyesuaikan ketinggian sikat secara proporsional atau independen dari ukuran dasar. |
| Kekuatan | Mengatur kekuatan sikat dari 0,1 hingga 1\. |
| Posisi Pivot | Atur titik pivot vertikal dari sikat ke bagian bawah, tengah, atau atas tempat sikat terhubung dengan medan yang ada. |
| Memasangkan | Apakah klik otomatis dimatikan atau ke vokel terdekat. |
| Pesawat Melapisi Flatten | Jika diatur ke Tetap , menyempurnakan medan ke rencana visual tetap di Y ruang dunia. |
| Abaikan Air | Mengabaikan air saat meratakan tanah. |
| Abaikan Bagian | Mengabaikan [bagian](/docs/id-id/parts) dalam hal penempatan sikat saat memindahkan pointer mouse di permukaan bagian. |
## [Jalan pintas studio](#jalan-pintas-studio)
Untuk alat yang menggunakan sikat ( Draw , Sculpt , Smooth , Flatten , Paint ), Studio mendukung tombol pintas keyboard dan mouse berikut.
| Jendela | Makan Mac | Tindakan |
| --- | --- | --- |
| Ctrl | ⌘ | Saat dipegang saat menggunakan alat [Menggambar](#draw) dan [Memahat](#sculpt) , beralih ke mode sikat cadangan.Sebagai contoh, beralih ke mode "pengurangan" alih\-alih mode "tambahan" default. |
| Shift | Shift | Saat dipegang saat menggunakan alat [Menggambar](#draw) dan [Memahat](#sculpt) , alat [Muluskan](#smooth) akan diaktifkan sementara. |
| B | B | Saat dipegang saat menyeret mouse atau menggunakan roda gulir, menyesuaikan ukuran dasar sikat . |
| CtrlB | ⌘B | Saat dipegang saat menyeret mouse atau menggunakan roda gulir, menyesuaikan ketinggian sikat tinggi .Hanya berlaku jika bentuk sikat diatur ke kotak atau silinder . |
| ShiftB | ShiftB | Saat dipegang saat menyeret mouse atau menggunakan roda gulir, menyesuaikan kekuatan sikat kekuatan .Hanya berlaku saat menggunakan alat [Memahat](#sculpt), [Melembutkan](#smooth), atau [Menyempurnakan](#flatten) tool. |
| Alt | ⌥ | Ketika ditekan saat mengklik mouse, menunjukkan pemilih materi. |
| 29 |
https://create.roblox.com/docs/id-id/studio/material-generator
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Generator Bahan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/material-generator).
Generator Material dirancang untuk membuat variasi materi dari entri teks.Menggunakannya, Anda dapat mengetik frasa apa pun dan menekan Hasilkan untuk melihat hasil dalam beberapa detik.Setelah menemukan hasil yang memuaskan, Anda dapat langsung menyimpannya sebagai bahan kustom baru.
## [Hasilkan materi](#hasilkan-materi)
Untuk menghasilkan materi, klik Menghasilkan dari dropdown [Pemilih Bahan](/docs/id-id/parts/materials#material-widget).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Material-Generator.png' alt='Studio's Model tab with the Material Generator button highlighted.' title='' width='704' height='' />Dengan jendela alat terbuka:
1. Di kotak teks di bagian atas jendela, masukkan kata kunci lalu klik tombol Hasilkan . Lihat [Praktik Terbaik](#best-practices) untuk panduan.
Seperti berikut adalah beberapa contoh kombinasi kata kunci dan hasil kira\-kira.Perhatikan bahwa setiap klik dari Menghasilkan menghasilkan hasil yang berbeda, bahkan dengan kata kunci yang persis sama.
Contoh 1
Contoh 2
Contoh 3
Contoh 4
"Kaca Terkolor"
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Material-Generator-Example-2D.jpg' alt='' title='' width='100%' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Material-Generator-Example-2C.jpg' alt='' title='' width='100%' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Material-Generator-Example-2A.jpg' alt='' title='' width='100%' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Material-Generator-Example-2B.jpg' alt='' title='' width='100%' height='' />
2. Klik ubin gambar yang dihasilkan untuk melihat lebih banyak opsi, serta menerapkan materi dalam mode "pratinjau" ke semua bagian yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Material-Generator-Expanded-Options.png' alt='' title='' width='220' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Material-Generator-Preview-On-Part.jpg' alt='' title='' width='540' height='' />
3. Sesuaikan slider Studs Per Tile untuk pratinjau interaktif bagaimana tekstur materi akan muncul di bagian yang dipilih.Selain itu, uji tombol Organik yang membuat materi tampak kurang "berulang" dengan merandomkan output.
[https://prod.docsiteassets.roblox.com/assets/modeling/materials/Material-Generator-Preview.mp4](https://prod.docsiteassets.roblox.com/assets/modeling/materials/Material-Generator-Preview.mp4)
*Penyesuaian dari nilai Studs Per Tile dan Organik toggle*
4. Saat siap, pilih Material Dasar untuk menerapkan properti fisik default [material tersebut](/docs/id-id/parts/materials#default-physical-properties) ke materi kustom Anda.Kemudian klik tombol Simpan \& Terapkan Varian untuk menyimpan materi khusus ke [Manajer Bahan](/docs/id-id/parts/materials#material-manager).
## [Praktik terbaik](#praktik-terbaik)
Membuat materi yang memuaskan bisa menjadi proses berulang yang membutuhkan daftar deskripsi yang lebih panjang untuk membantu fokus pada materi yang Anda inginkan.Berikut adalah beberapa tips:
* Untuk pola dekat, coba gunakan istilah seperti "dekat," "bawah," dan "tekstur."
* Untuk pola pengulangan yang lebih sederhana, coba gunakan istilah seperti "sederhana," "pola," "simetris," dan "datar."
* Untuk kontrol lebih, tambahkan istilah stylistik seperti "fotorealistik," "kartun," atau "hand\-drawn."
* Untuk kemampuan untuk mengubah warna, coba termasuk istilah seperti "grayscale" yang akan memungkinkan Anda untuk menyuburkan material setelahnya.
| 30 |
https://create.roblox.com/docs/id-id/studio/texture-generator
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Pembangkit Textur
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/texture-generator).
props.leadIn File \> Fitur Beta \> props.betaName props.leadOutAlat Pembuat Tekstur dirancang untuk dengan cepat membuat teksur khusus untuk meshes Anda melalui prompt teks.Anda dapat memilih mesh atau [Model](/docs/id-id/reference/engine/classes/Model) terdiri dari beberapa mesh, ketikkan prompt apa pun untuk melihat pratinjau hasil dalam beberapa detik, lalu menghasilkan teksur lengkap.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Generation-Rusted-Metal-Charred.jpg' alt='' title='' width='100%' height='' />
*"Kastil Logam Berkarat"*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Generation-Mossy-Stone.jpg' alt='' title='' width='100%' height='' />
*"Benteng Batu Mossy"*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Generation-Snow-Covered-Ice.jpg' alt='' title='' width='100%' height='' />
*"Patung Es Tertutup Salju"*
Pembangkit Teksur paling cocok untuk aset 3D khusus di mana tekstur yang diinginkan bersifat kontekstual pada aset itu sendiri.Untuk menghasilkan gambar berulang atau berbalok untuk permukaan tekstur seperti lantai kayu atau jalur batu kali, [Pembangkit Bahan](/docs/id-id/studio/material-generator) dapat menghasilkan hasil yang lebih baik.
1 Saat menghasilkan tekstur untuk kelompok , meshes harus diatur dengan cara yang masuk akal sehingga tubuh yang terpadu terbentuk.Hindari menghasilkan teksur untuk kelompok acak meshes yang tersebar di sekitar batas model, atau untuk lebih dari satu mesh identik di operasi yang sama.
## [Hasilkan tekstur](#hasilkan-tekstur)
Untuk mulai menghasilkan teksur, navigasikan ke tab [Model](/docs/id-id/studio/model-tab) dan buka alat Pembangkit Teksur .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Texture-Generator.png' alt='Texture Generator indicated in Model tab' title='' width='704' height='' />Dengan jendela alat terbuka:
1. Pilih [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) atau [Model](/docs/id-id/reference/engine/classes/Model) yang terdiri dari [MeshParts](/docs/id-id/reference/engine/classes/MeshPart) di adegan Anda.
2. Di jendela pratinjau alat, klik dan seret untuk mengatur sudut [generasi](#generation-angle) yang menyoroti fitur atau permukaan penting untuk teksturisasi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Generation-Angle-Good.png' alt='Good generation angle focusing on primary faces of a tower mesh' title='' width='280' height='' />
*Fokus pada wajah utama dari meshes menara, terlihat oleh pemain*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Generation-Angle-Bad.png' alt='Bad generation angle focusing on bottom of tower mesh' title='' width='280' height='' />
*Bagian bawah jaring menara tidak mungkin terlihat oleh pemain*
3. Masukkan perintah yang menggambarkan tekstur yang diinginkan, misalnya:
* “Kastil Logam Berkarat Berkilau”
* “Benteng Batu Mossy”
* “Patung Es Tertutup Salju”Menggunakan lebih banyak deskripsi dalam prompt dan mengulang dapat membantu Anda menemukan tekstur yang sesuai dengan kebutuhan Anda.Untuk informasi lebih lanjut, lihat [Praktik Terbaik](#best-practices).
4. Klik Pratinjau untuk membuat pratinjau tekstur secara real time.Proses ini biasanya memakan waktu sekitar 20 detik tetapi dapat lebih lama selama periode puncak.
Saat Anda menemukan tekstur yang tampak sesuai, gunakan tombol "putar" untuk memutar pandangan 90° di sekitar mesh.Untuk kembali ke input prompt untuk mengulang dan/atau membuat pratinjau baru, klik tombol "kembali."
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Generation-Post-Preview.png' alt='Texture preview showing in tool window' title='' width='280' height='' />Pada titik ini, tekstur mungkin tidak terlihat konsisten secara visual dari semua empat pandangan.Namun, model akan membuat tekstur yang lebih konsisten selama proses pembuatan tekstur.
5. Ketika Anda puas dengan tekstur, klik Simpan \& Terapkan untuk membuat tekstur lengkap untuk mesh Anda.Proses ini biasanya membutuhkan beberapa menit tetapi bisa lebih lama selama periode puncak.Saat selesai, teksur baru akan diterapkan ke mesh melalui kejadian[SurfaceAppearance](/docs/id-id/reference/engine/classes/SurfaceAppearance) .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Texture-Applied.jpg' alt='Texture applied to mesh in 3D world' title='' width='720' height='' />Tekstur akhir yang dihasilkan akan menjadi mencocokkandekat dengan apa yang Anda amati di jendela pratinjau, tetapi mungkin tidak persis cocok.Anda dapat terus mengulang pada perintah gaya dan membandingkan versi sebelumnya seperti yang dijelaskan di [Mengelola Tekstur](#managing-textures).
## [Manajemen tekstur](#manajemen-tekstur)
Tekstur yang dihasilkan muncul di bagian Tekstur yang disimpan dari jendela alat.Untuk setiap teksur, Anda dapat klik ⋯ untuk mengakses berbagai opsi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Saved-Textures-List.png' alt='Saved Textures list in tool window' title='' width='280' height='' />
| Pilihan | Deskripsi |
| --- | --- |
| Sisipkan Mesh dengan Tekstur | Memasukkan salinan mesh/model bertekstur ke dalam ruang kerja. |
| Tampilkan di Inventaris | Membuka inventaris Gambar Anda di [Dashboard Pencipta](https://create.roblox.com/dashboard/creations?activeTab=Image) di mana Anda dapat memeriksa gambar tekstur. |
| Ekspor | Mengekspor mesh ke sistem lokal Anda sebagai file .obj . |
| Menghapus | Menghapus tekstur dari daftar Teks Tersimpan . |
## [Opsi lanjutan](#opsi-lanjutan)
Memperluas bagian Opsi Lanjutan di jendela alat memungkinkan Anda untuk mengonfigurasi aspek berikut.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Advanced-Options.png' alt='Advanced Options panel in tool window' title='' width='280' height='' />
### [Kontrol kedelai](#kontrol-kedelai)
Anda dapat memilih untuk mengacak benih atau menetapkan benih khusus untuk generasi tekstur.Mengatur benih spesifik sebelum menghasilkan teksur memastikan Anda mendapatkan hasil konsisten setiap kali menggunakan prompt khusus.
### [Sudut generasi](#sudut-generasi)
Memungkinkan Anda untuk mengatur sudut generasi utama untuk diprioritaskan selama fase pratinjau generasi untuk memastikan area mesh paling penting terlihat dan dapat diberi tekstur.Sudut ini juga dikontrol dengan mengklik dan menyeret mesh di jendela pratinjau.
Lihat [Praktik Terbaik](#best-practices) untuk rekomendasi terperinci tentang memilih sudut generasi.
### [Pembungkusan UV Cerdas](#pembungkusan-uv-cerdas)
Dalam Modeling3D, peta UV adalah representasi 2D dari permukaan model 3D, memungkinkan teksur 2D diterapkan dengan akurat ke model 3D.Koordinat UV U dan V merujuk pada sumbu horizontal dan vertikal dari ruang 2D ini, mirip dengan sumbu X dan Y di grafik 2D.
Untuk alat generator tekstur untuk membuat tekstur yang terbentuk dengan baik, peta UV dasar mesh Anda harus sesuai dengan beberapa panduan.Pertama, semua koordinat UV harus berada di dalam kotak unit , karena peta UV di luar kotak unit akan berkeliling ke sisi lain peta UV dan membuat artefak atau celah di tekstur akhir.Kedua, semua UV harus tidak tumpang tindih , karena UV tumpang tindih akan menghasilkan teks dan penempatan warna yang tidak konsisten.
Memilih opsi Pencopotan UV Cerdas akan mengambil mesh tanpa UV (atau UV yang tidak kompatibel) dan menerapkan koordinat UV yang diperlukan untuk teksturisasi.Jika UV Anda kompatibel, mereka tidak akan terpengaruh dan Anda dapat menggunakan mesh as\-is.
### [Spesifikasikan pandangan depan](#spesifikasikan-pandangan-depan)
Ketika pengaturan ini diaktifkan, sudut [generasi](#generation-angle) yang dipilih selama tahap pratinjau ditentukan sebagai "depan" dari mesh Anda.Ini memungkinkan alat untuk lebih baik membuat meshes tekstur dengan bagian depan dan belakang yang jelas dengan mengidentifikasi setiap sisi, sehingga tercipta teksur yang lebih konsisten dan koheren.Ini sangat membantu untuk objek dengan depan dan kembaliyang jelas, seperti avatar, hewan, dan pakaian.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Specify-Front-View-Bad-Front.jpg' alt='Front view of character's lab coat with Specify Front View disabled' title='' width='100%' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Specify-Front-View-Bad-Back.jpg' alt='Back view of character's lab coat with Specify Front View disabled' title='' width='100%' height='' />
*"Lab Coat with Badge" prompt dengan Spesifikasi Pandangan Depan dinonaktifkan, menghasilkan jaket lab "depan" di depan dan belakang*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Specify-Front-View-Good-Front.jpg' alt='Front view of character's lab coat with Specify Front View enabled' title='' width='100%' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/texture-generator/Specify-Front-View-Good-Back.jpg' alt='Back view of character's lab coat with Specify Front View enabled' title='' width='100%' height='' />
*Prompt yang sama dengan Spesifikasi Pandangan Depan diaktifkan, menghasilkan "depan" dan "kembali" lab coat yang benar*
## [Praktik terbaik](#praktik-terbaik)
Mengingatkan tips
Sudut generasi
Pembaruan berulang
Tip perintah berikut memungkinkan alat untuk memberikan hasil yang lebih baik dan lebih konsisten.
* Berikan sedetail mungkin dalam prompt Anda. Prompt singkat dan vage akan mengarah pada hasil yang tidak konsisten atau tak terduga.
* Termasuk atribut tekstur seperti jenis bahan, warna, pola, penggunaan, dan lainnyaSemakin banyak batasan yang Anda berikan kepada alat, semakin baik alat dapat menghasilkan apa yang ada di pikiran Anda.
* Gunakan frasa deskriptif alih\-alih kata\-kata tunggal untuk item kunci, misalnya "kulit aus" alih\-alih hanya "kulit."
* Tambahkan petunjuk gaya seperti "sinematik," "fotorealistik," "kartun," atau "low poly" untuk mempengaruhi tampilan keseluruhan.
| 31 |
https://create.roblox.com/docs/id-id/studio/rig-builder
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Pembangun Rig
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/rig-builder).
Alat Pembangun Rig memungkinkan Anda dengan cepat menyisipkan karakter dasar yang sudah dibangun ke dalam pengalaman Anda.Anda juga dapat menyisipkan rig karakter avatar akun Anda, termasuk kustomisasi karakter dan aksesori.Alat ini menyisipkan karakter [Models](/docs/id-id/reference/engine/classes/Model) dengan persambungan yang tepat dan struktur humanoid untuk mendukung [animasi](/docs/id-id/animation) , [aksesori](/docs/id-id/art/accessories) , dan [kustomisasi karakter](/docs/id-id/characters/appearance) .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/rig-builder/Rig-Examples.jpg' alt='' title='' width='100%' height='' />
*Contoh karakter rig dimasukkan ke dalam jendela pandang 3D*
Anda dapat menyisipkan semua jenis rig pra\-dibangun langsung dari popup ke viewport Anda.
1. Dari tab Avatar di bilah alat, klik Pembangun Rig .
2. Dari pop\-up, pilih dari opsi yang tersedia.Anda dapat menyisipkan dua jenis rig ke dalam pengalaman Anda: R6 adalah rig lama yang terdiri dari 6 objek mesh, sementara R15 terdiri dari 15 objek mesh, secara signifikan memperluas rentang gerak terbatas R6\.
Perhatikan bahwa Anda hanya dapat melengkapi pakaian dan aksesori lapisan lain ke R15 model.
3. Pilih bentuk tubuh dari Masculine atau Feminine dan kemudian klik salah satu tombol gaya.Rig ditampilkan di kedua jendela pandang 3D dan di jendela [Explorer](/docs/id-id/studio/explorer) di bawah nama Rig .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Rig-Hierarchy.png' alt='' title='' width='320' height='' />
| 32 |
https://create.roblox.com/docs/id-id/studio/script-editor
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Editor naskah
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/script-editor).
Editor skrip di Studio adalah alat utama untuk menulis skrip di Roblox .Ini adalah lingkungan yang ditingkatkan sendiri yang dapat membantu Anda menulis kode berdampak tinggi, mengurangi waktu pengembangan Anda, dan mengulangi pengalaman Anda.Ini dapat meningkatkan pengalaman penulisan skrip Anda dengan:
* Memformat dan menyoroti sintaks dalam kode Anda.
* Menawarkan cara untuk [mengisi ulang otomatis](#autocomplete-features) frasa di kode Anda saat Anda ketik.
* Membantu Anda [menavigasi kode](#code-navigation) dengan melompat ke deklarasi variabel dan fungsi.
* Membantu Anda [menemukan dan mengganti](#find-and-replace) kode di skrip terbuka atau semua skrip.
* Memberikan [masukan real\-time](#real-time-feedback) pada pelaksanaandan kinerja kode Anda.
Editor Skrip mendukung semua jenis [skrip](/docs/id-id/scripting) dan membuka secara otomatis saat Anda membuat skrip baru atau mengklik dua kali skrip yang ada di jendela [Explorer](/docs/id-id/studio/explorer).
Anda dapat [menyesuaikan](#editor-settings) Editor Skrip untuk sesuai dengan preferensi dan alur kerja Anda, termasuk keluarga huruf/ukuran, perilaku penyajian, dan warna untuk penyorotan sintaks.Anda juga dapat menyalakan fitur seperti [penyelesaian otomatis](#autocomplete), [bantuan tanda tangan](#signature-help), dan [analisis skrip](#script-analysis).
## [Fitur penyelesaian otomatis](#fitur-penyelesaian-otomatis)
Fitur penyelesaian otomatis Editor Skrip menghasilkan informasi terkait kode yang dapat meningkatkan efisiensi pemrograman Anda, seperti:
* Saran terinformasi tentang cara menyelesaikan frasa saat Anda mengetiknya yang bersifat kontekstual pada model data pengalaman .Sebagai contoh, jika Anda memiliki [Model](/docs/id-id/reference/engine/classes/Model) di [Workspace](/docs/id-id/reference/engine/classes/Workspace) yang disebut RocketShip , autocomplete menyarankan RocketShip ketika Anda mengetik workspace.roc dan menunjukkan bahwa itu adalah [Model](/docs/id-id/reference/engine/classes/Model) .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Autocomplete-Data-Model.png' alt='Autocomplete showing suggestions based on the experience's data model' title='' width='780' height='' />Gunakan tombol ↑ dan ↓ untuk menelusuri saran, lalu tekan Tab atau Enter untuk menerima saran dan memasukkan frasa lengkap.
* Isi otomatis nama untuk variabel dan fungsi yang Anda menyatakan, membantu Anda menghindari kesalahan ketik yang menjengkelkan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Autocomplete-Variable.png' alt='Autocomplete showing suggestions based on a previously declared variable.' title='' width='780' height='' />
* Popup dokumentasi dengan sampel kode yang mirip dengan yang ada di [Referensi API Mesin](/docs/id-id/reference/engine), memberi Anda konteks tentang penggunaan API.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Autocomplete-API.png' alt='Autocomplete showing suggestions based on a Roblox Engine API.' title='' width='780' height='' />
* Tip alat di atas mouse yang dapat Anda kustomisasi dengan dokumentasi yang didefinisikan sendiri.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Autocomplete-CustomDocs.png' alt='Autocomplete showing custom documentation.' title='' width='780' height='' />
* Diagnosis analisis skrip on\-hover dengan informasi yang dapat Anda gunakan untuk memecahkan masalah kesalahan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Autocomplete-Diagnostics.png' alt='Autocomplete showing diagnostic information.' title='' width='780' height='' />
* Tanda tangan fungsi saat Anda mengetik argumen, memberi Anda referensi untuk parameter dan nilai kembali.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Autocomplete-Signature.png' alt='Autocomplete showing function signature' title='' width='780' height='' />
## [Navigasi kode](#navigasi-kode)
### [Pergi ke deklarasi](#pergi-ke-deklarasi)
Anda dapat melompat ke deklarasi fungsi atau variabel dengan menahan Ctrl di Windows atau ⌘ di Mac saat mengklik panggilan, atau dengan mengklik kanan panggilannya dan mengklik Pergi ke Deklarasi .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Go-To-Declaration.png' alt='Go to Declaration workflow on a declared function' title='' width='800' height='' />
### [filterfungsi skrip](#filterfungsi-skrip)
Fungsi Filter Skrip menampilkan daftar semua fungsi yang dideklarasikan dalam skrip.Untuk membukanya, tekan AltF di Windows atau ⌥F di Mac.Dengan daftar terbuka, Anda dapat menelusuri tanda tangan untuk setiap fungsi, filter melalui nama, dan klik dua kali untuk melompat ke deklarasinya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Script-Functions-Filter.png' alt='Script Function Filter showing all functions inside a script' title='' width='800' height='' />
## [Temukan dan ganti](#temukan-dan-ganti)
Widget Temukan/Ganti memungkinkan Anda menemukan dan mengganti kode di skrip terbuka. Widget mendukung kasus cocok, mencocokkan seluruh kata, dan mencari dengan ekspresi reguler.Untuk membukanya, tekan CtrlF di Windows atau ⌘F di Mac.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Find-Replace-Widget-Labeled.png' alt='Find/Replace widget labeled' title='' width='760' height='' />Untuk pencarian yang lebih luas, jendela Temukan Semua/Ganti Semua memungkinkan Anda menemukan/mengganti kode di berbagai skrip dalam pengalaman.Untuk membukanya, tekan pada Windows atau pada Mac.
## [Umpan balas masukannyata](#umpan-balas-masukannyata)
### [Analisis Skrip](#analisis-skrip)
Jendela Analisis Skrip dapat diakses dari tab [Pandangan](/docs/id-id/studio/view-tab), melakukan analisis statis pada skrip Anda dan menampilkan kesalahan dan peringatan aktif.Untuk informasi lebih lanjut tentang kesalahan dan peringatan, lihat dokumentasi [Luau linting](https://luau-lang.org/lint).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Script-Analysis-1.png' alt='Script with various marked errors' title='' width='800' height='' />
*Kesalahan skrip disorot di Editor Skrip*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Script-Analysis-2.png' alt='Script Analysis window with details on marked errors from script' title='' width='800' height='' />
*Kesalahan dijelaskan di jendela Analisis Skrip*
### [Output](#output)
Jendela Keluaran yang dapat diakses dari tab [Pandangan](/docs/id-id/studio/view-tab), menampilkan kesalahan yang ditangkap dari menjalankan skrip, pesan dari Roblox Engine, pesan dari panggilan ke print() , dan kesalahan dari panggilan ke warn() .Untuk rincian tentang konfigurasi untuk alur kerja Anda, lihat [Output](/docs/id-id/studio/output).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Output-Window.png' alt='' title='' width='800' height='' />
## [Asisten Kode](#asisten-kode)
Asisten Kode adalah fitur yang menyarankan baris atau fungsi kode saat Anda ketik, membantu Anda menulis kode lebih efisien dan tetap fokus.Berdasarkan konteks dari komentar dan kode Anda, saran akan dipicu dalam dua cara:
* Secara otomatis saat Anda berhenti di satu baris selama beberapa detik dan model AI memiliki cukup konteks untuk saran.
* Secara manual dengan pintasan pada Windows atau pada Mac (Anda dapat kustomisasi pintasan ini).
Tekan Tab untuk menerima saran, atau abaikan dengan terus ketik.Saat ini, skrip Anda harus berisi setidaknya beberapa baris kode untuk memicu saran.
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Code-Assist.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/Code-Assist.mp4)
Asisten Kode membantu otomatisasi tugas pemrograman dasar sehingga Anda dapat fokus pada pekerjaan kreatif, tetapi tidak selalu menyarankan kode sempurna (lihat [Batasan](#limitations)).Masih tanggung jawab Anda untuk meninjau, me\-review, dan menentukan apakah saran kode sesuai konteks.
### [Tingkatkan saran](#tingkatkan-saran)
Untuk mendapatkan saran yang lebih akurat dan relevan, disarankan agar Anda mengikuti praktik koding bersih, terlepas dari bantuan, dan:
* Memecah kode Anda menjadi fungsi yang lebih kecil.
* Gunakan nama skrip deskriptif yang menangkap niat umum dari apa yang dilakukan setiap skrip.Sebagai contoh, beri nama skrip SinkronisasiSuaraKustom alih\-alih hanya Suara .
* Tetuk nama deskriptif untuk parameter, fungsi, dan skrip.Sebagai contoh, beri nama bagian GreenSphere alih\-alih hanya grs , atau beri nama fungsi generateSphere() alih\-alih gen().Menggunakan fungsi bernama versus fungsi anonim juga dapat menghasilkan petunjuk yang lebih baik.
* Secara konsisten termasuk komentar yang ditulis dengan baik [yang menggambarkan tugas yang Anda terapkan dan apa yang harus menjadi input/ output](/docs/id-id/luau/comments).
+ Pertimbangkan untuk menyertakan beberapa panggilan sampel dengan hasil yang diharapkan dalam komentar.
+ Saran bagaimana memecahkan masalah, misalnya \-\- Use raycast .
+ Gunakan fungsi atau nama variabel yang tepat yang Anda definisikan, misalnya \-\- Create 10 greenSphere objects alih\-alih \-\- Create 10 spheres.
* Jika Anda seorang pemogram pemula, mulailah dengan proyek dasar seperti "membuat pemain melompat saat mereka menyentuh bagian" atau gunakan alat untuk menghasilkan potongan kode kecil yang dapat Anda perluas saat pengetahuan Anda tumbuh.
### [Keterbatasan](#keterbatasan)
Alat ini membantu otomatisasi tugas pemrograman dasar tetapi tidak selalu menyarankan kode sempurna. Batasan yang dikenal termasuk:
* Pemicu manual tidak selalu memaksakan menghasilkan saran.
* Saran dipelajari oleh mesin dari kumpulan kode dan dapat mencerminkan beberapa batasan kode yang mereka latih.Sebagai contoh, saran mungkin tidak menggunakan API baru untuk mendukung API lama, atau mereka dapat menggunakan Lua alih\-alih [Luau](/docs/id-id/luau).
* Alat dapat menghasilkan informasi yang salah atau menyesatkan yang tidak berguna untuk tujuan Anda.
* Filter internal berusaha untuk memblokir bahasa ofensif, tetapi mereka tidak menyeluruh dan ada kemungkinan alat dapat menghasilkan informasi ofensif atau berpihak.
* Saran mungkin sama, serupa, atau berbeda di antara pengguna, bahkan dengan perintah yang sama. Namun kode Anda tidak akan pernah dibagikan dengan orang lain.
* Saran mungkin tidak lengkap karena panjang output terbatas dari model pembelajaran.
* Ada batas harian untuk jumlah saran dan, setelah batas tercapai, Anda tidak akan mendapatkan saran sampai hari berikutnya.
### [privasi](#privasi)
Saat ini, Roblox tidak menggunakan data non\-publik apa pun untuk melatih model pembelajaran.Alat hanya menggunakan subset kecil dari aset pasar gratis untuk menyetel model bahasa besar dan subset telah melewati berbagai pemeriksaan untuk filter kualitas dan keamanan.
Selain itu, semua saran dihasilkan oleh model AI dan tidak mentransfer dari satu pengguna ke pengguna lain.Karena kode Anda tidak digunakan untuk pelatihan model, itu tidak akan disarankan kepada pengguna lain dari Asisten Kode , dengan satu pengecualian kode diposting ke item pasar gratis.
## [Multi\-kursor](#multi-kursor)
Editor Skrip mendukung penggunaan beberapa kursor untuk membuat perubahan secara bersamaan.Anda dapat menambahkan kursor berdasarkan kebutuhan Anda dengan klik mouse atau pintasan keyboard.Kursor awal disebut kursor utama dan kursor tambahan disebut kursor sekunder .
* Edit yang Anda buat pada salinan kursor utama ke kursor sekunder.Setiap edit dihitung sebagai satu action, jadi membatalkan/menyelesaikan edit berlaku untuk semua kursor.
* Widget seperti [penyelesaian otomatis](#autocomplete-features) muncul di kursor utama tetapi bukan kursor sekunder.
* Semua pintasan keyboard standar [untuk pekerjaan pengeditan skrip](#keyboard-shortcuts) dengan multi\-kursor editing, termasuk penandaan kode, menyalakan komentar, dan menghapus baris.
Tabel berikut menyimpulkan alur kerja multi\-kursor dan jalan pintasnya.
| Perintah | Jendela | Makan Mac |
| --- | --- | --- |
| Tambahkan/hapus kursor di lokasi mouse | Alt \+ klik | ⌥ \+ klik |
| Hapus kurator terbaru yang ditambahkan | CtrlU | ⌘U |
| Tambahkan/modifikasi kursor saat seretan mouse | Alt \+ seretan | ⌥ \+ seretan |
| Tambahkan kursor di atas/di bawah | CtrlAlt↑ / CtrlAlt↓ | ⌘⌥↑ / ⌘⌥↓ |
| Tambahkan kursor ke seleksi berikutnya yang cocok | CtrlD | ⌘D |
| Tambahkan kursor ke setiap pilihan yang cocok | ShiftAltL | Shift⌥L |
| pilihkolom/blok | ShiftAlt \+ seret | Shift⌥ \+ seret |
| Membagi seleksi menjadi baris | ShiftAltI | Shift⌥I |
Untuk menghapus semua kursor sekunder, keluar dari pengeditan kursor multi, dan kembali ke kursor utama, tekan Esc .
### [Tambahkan kursor](#tambahkan-kursor)
Anda dapat menambahkan kursor dengan kombinasi pintasan keyboard dan manuver mouse.Kursor bergabung jika mereka menduduki ruang yang sama, seperti jika Anda menambahkan kursor dengan tombol panah atau menghapus semua karakter di antara kursor.
#### [Pada lokasi mouse](#pada-lokasi-mouse)
Untuk menambahkan kursor di lokasi pointer mouse Anda:
1. Tahan Alt di Windows atau ⌥ di Mac.
2. Klik di mana Anda ingin menambahkan kursor.
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/AddWithClick.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/AddWithClick.mp4)
#### [Dengan seretan mouse](#dengan-seretan-mouse)
Anda dapat menyeret mouse untuk menambahkan kursor ke seleksi, membagi seleksi multi\-baris menjadi baris, atau memilih kolom dan blok kode/ruang kosong.
Seret pilih
Dibagi menjadi baris
pilihkolom/blok
Untuk menambahkan kursor ke seleksi kode melalui seretan:
1. Tahan Alt di Windows atau ⌥ di Mac.
2. Klik dan seret mouse Anda di atas pilihan kode.
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/AddWithDrag.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/AddWithDrag.mp4)
#### [Di atas dan di bawah kursor utama](#di-atas-dan-di-bawah-kursor-utama)
Untuk menambahkan kursor langsung di atas atau di bawah kursor utama:
1. Tekan dan tahan CtrlAlt di Windows atau ⌘⌥ di Mac.
2. Tekan panah ↑ atau ↓ .
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/AddAboveBelow.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/AddAboveBelow.mp4)
#### [Untuk mencocokkan pilihan](#untuk-mencocokkan-pilihan)
Anda dapat menambahkan kursor ke semua pertandingan dari seleksi atau ke mencocokkanberikutnya/sebelumnya, dan secara opsional beralih apakah pertandingan sesuai dengan sensitif huruf besar/kecil dan/atau cocok dengan seluruh kata.
Semua cocok
mencocokkanberikutnya/sebelumnya
Pencocokan kata kunci atau seluruh mencocokkan
Untuk menambahkan kursor ke semua pertandingan dari bagian yang dipilih:
1. Pilih kode yang ingin Anda cari cocokan.
2. Tekan ShiftAltL pada Windows atau Shift⌥L pada Mac.
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/AddToAllMatches.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/AddToAllMatches.mp4)
### [Hapus kursor](#hapus-kursor)
Anda dapat menghapus kursor dengan shortcut keyboard dan manuver mouse berikut.Alternatifnya, Anda dapat keluar dari pengeditan multi\-kursor dengan menekan Esc .
#### [Pada lokasi mouse](#pada-lokasi-mouse-1)
Untuk menghapus kursor:
1. Tekan dan tahan Alt di Windows atau ⌥ di Mac.
2. Klik kursor yang ingin Anda hapus.
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/RemoveWithClick.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/RemoveWithClick.mp4)
#### [Terbaru ditambahkan](#terbaru-ditambahkan)
Untuk menghapus kursor yang paling baru ditambahkan, tekan CtrlU di Windows atau ⌘U di Mac.
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/UndoRecentCursor.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/UndoRecentCursor.mp4)
### [Salin dan tempel kursor](#salin-dan-tempel-kursor)
Menyalin pilihan kode termasuk kursor di dalamnya.Perilaku paste tergantung pada jumlah kursor di sumber dan jumlah kursor di tujuan:
* Jika jumlah kursor sama, maka setiap kursor yang disalin ditempel ke kurikuler tujuan yang sesuai.
* Jika jumlah kursor berbeda, maka setiap kursor di tujuan menerima seluruh paste dengan setiap kursor yang disalin sebagai baris baru.
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/CopyPaste.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/CopyPaste.mp4)
### [Formatasi tipe pada saat itu](#formatasi-tipe-pada-saat-itu)
Menekan enter/return akan secara otomatis mengidentifikasi setiap kursor di baris baru relatif terhadap baris sebelumnya.Jika baris sebelumnya dimulai dengan blok yang tidak lengkap, formatter akan mencoba untuk menyelesaikannya.
[https://prod.docsiteassets.roblox.com/assets/studio/script-editor/OnTypeFormatting.mp4](https://prod.docsiteassets.roblox.com/assets/studio/script-editor/OnTypeFormatting.mp4)
## [Pengaturan editor](#pengaturan-editor)
Banyak opsi kustomisasi dapat diakses melalui File ⟩ Pengaturan Studio ( AltS di Windows; ⌥S di Mac).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Studio-Settings-Script-Editor.png' alt='A close up view of the Studio Settings window with the Script Editor tab selected.' title='' width='750' height='' />Opsi yang dimodifikasi secara umum termasuk:
| Pilihan | Deskripsi |
| --- | --- |
| Jenis huruf | Wajah dan ukuran huruf untuk kode di editor. |
| Lebar tab | Jumlah ruang yang mewakili indentasi Tab . |
| Mengidentifikasi menggunakan spasi | Jika diaktifkan, ruang yang sama dengan Lebar Tab dimasukkan dengan tekan Tab. |
| Pengemasan teks | Jika diaktifkan, baris kode yang lebih panjang dibungkus ke baris berikutnya. |
| Prasetel warna Editor Skrip | Prasetel warna untuk elemen kode, warna seleksi, dan banyak lagi.Setelah memilih prasetel, Anda dapat mengatur warna spesifik untuk opsi seperti Warna Pilihan dan Komentar Warna . |
## [Jeda pintasan keyboard](#jeda-pintasan-keyboard)
Editor Skrip memiliki shortcut keyboard berikut.Anda juga dapat mengakses banyak perintah dari tab [Skrip](/docs/id-id/studio/script-tab) yang muncul di bilah alat Studio setiap kali Anda melihat atau mengedit skrip.
File dan tampilan
Editasi dasar
Kursor Multi
| Perintah | Jendela | Makan Mac |
| --- | --- | --- |
| Tutup skrip | CtrlW | ⌘W |
| Buka kembali skrip terakhir yang ditutup | CtrlShiftT | ⌘ShiftT |
| Buka cepat | CtrlP | ⌘P |
| Tampilkan skrip di Explorer | CtrlAltK | ⌘⌥K |
| Perbesar | Ctrl\= | ⌘\= |
| Perbesar keluar | Ctrl\- | ⌘\- |
| Setel ulang zoom skrip | Ctrl0 | ⌘0 |
| 33 |
https://create.roblox.com/docs/id-id/studio/debugging
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Depurasi
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/debugging).
Studio menawarkan banyak alat debug yang umum ditemukan di Integrated Development Environments (IDEs).Alat\-alat ini membantu Anda memecahkan masalah dan memeriksa skrip baris demi baris saat dijalankan.Informasi debug ditampilkan di [Tonton](#watch) , [Tumpukan Panggilan](#call-stack) , [Titik Pemutusan](#breakpoints-window) , dan [Output](#output) jendela untuk Anda periksa.
## [Alur kerja umum](#alur-kerja-umum)
Jika Anda melihat masalah dalam pengalaman Anda atau ingin memverifikasi bahwa itu berfungsi seperti yang Anda rencanakan, Anda dapat mendepur kode yang terkait dengannya sebagai berikut:
1. [Sisipkan titik istirahat](#insert-breakpoints) pada baris kode yang ingin Anda periksa.
2. Di tab [Skrip](/docs/id-id/studio/script-tab), klik Mainkan atau Jalankan di tab tes untuk memulai sesi pengujian, juga dikenal sebagai sesi debugging.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Script-Tab-Playtest-Options.png' alt='Playtest options in Script tab.' title='' width='780' height='' />
3. Ketika skrip mencapai titik istirahat, sesi pengujian berhenti.Periksa [Jam Tangan](#watch), [Tumpukan Panggilan](#call-stack), dan [Jendela Keluaran](#output) untuk membantu Anda mendiagnosis dan memahami masalah.
4. Sisipkan titik istirahat tambahan pada baris kode yang belum dieksekusi untuk memeriksa data tambahan.[Nonaktifkan](#disable-breakpoints) atau [hapus](#delete-breakpoints) titik pemutus yang tidak Anda butuhkan lagi.
5. Di tab Skrip , klik Hentikan untuk mengakhiri sesi debugging.
Ulangi langkah sebelumnya sampai Anda memecahkan masalah atau menemukan penyebab akar masalahnya.Saat Anda mempelajari alur kerja umum, Anda dapat mengonfigurasi titik istirahat untuk hanya pecah jika kondisi tertentu dipenuhi, untuk mencetak pesan ke jendela [Output](#output), dan untuk dijalankan hanya di klien atau server.Untuk informasi lebih lanjut, lihat [Konfigurasi Titik Pemutus](#breakpoint-configurations).
### [Sisipkan titik istirahat](#sisipkan-titik-istirahat)
Breakpoint adalah titik pemeriksaan yang membekukan atau "memutus" eksekusi skrip Anda di baris tertentu.Anda dapat menggunakan jeda untuk memeriksa dan mem debug pengalaman Anda, [menonton](#watch) variabel, dan memeriksa [tumpukan panggilan](#call-stack).Breakpoint adalah salah satu cara paling efektif untuk mem debug fungsi, jadi mereka adalah salah satu alat debugging paling penting.Anda dapat menyisipkan titik istirahat di baris kode eksekutif mana pun.
Untuk menyisipkan titik istirahat standar di baris kode, klik kiri margin ke kanan nomor barisnya.Anda juga dapat mengklik kanan margin dan klik Tambahkan Titik Pemutus.Breakpoint muncul sebagai titik merah.Untuk menonaktifkannya, klik titik.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Gutter-Breakpoint.png' alt='Breakpoint in gutter is a red dot' title='' width='320px' height='' />
### [Langkah melalui kode](#langkah-melalui-kode)
Jika Anda menyisipkan titik istirahat di baris dalam skrip, skrip berhenti sebelum mengeksekusi baris itu.Panah kuning yang disebut "debugger" menunjukkan baris kode mana yang dieksekusi berikutnya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Gutter-Breakpoint-Active.png' alt='Active breakpoint in the debugger shows yellow arrow' title='' width='320px' height='' />Ketika skrip berhenti, jalankan kode berikut satu per satu dengan melangkah melalui mereka dengan tombol di tab [Skrip](/docs/id-id/studio/script-tab).Tombol juga muncul di sudut kiri atas jendela [Tumpukan Panggilan](#call-stack).Saat Anda melangkah melalui kode, awasi bagaimana pengalaman Anda berubah saat baris saat ini dieksekusi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Script-Tab-Debugging-Tools.png' alt='Debugging tools indicated in Script tab' title='' width='663' height='' />Tabel berikut menyajikan tiga cara untuk melangkah melalui kode.Untuk melanjutkan mengeksekusi kode Anda setelah Anda mencapai titik istirahat, klik Lanjutkan di tab Skrip .
| Tombol | Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- | --- |
| Button to step into a line of code | Langkah ke dalam | F11 | Tombol Langkah ke dalam memindahkan debugger ke kode fungsi pada baris saat ini.Jika tidak ada fungsi di baris saat ini, debugger pindah ke baris berikutnya. |
| Button to step over a line of code | Langkah Melampaui | F10 | Tombol Langkah Melampaui memindahkan debugger ke baris kode berikutnya, tidak bergerak ke fungsi. |
| Button to step out of a line of code | Langkah Keluar | ShiftF11 | Tombol Langkah Keluar memindahkan debugger keluar dari fungsi saat ini dan ke baris kode berikutnya setelah panggilan fungsi.Jika baris saat ini tidak berada di dalam fungsi, debugger pindah ke baris berikutnya. |
### [Periksa kode](#periksa-kode)
Ketika titik istirahat menghentikan pengalaman selama tes permainan, Anda dapat memeriksa jendela [Tonton](#watch) jendela, [Tumpukan Panggilan](#call-stack) jendela, [Output](#output) jendela, dan [Editor Skrip](#script-editor) untuk menemukan informasi tentang nilai variabel dan eksekusi fungsi.Dengan informasi ini, Anda dapat menemukan penyebab akar masalah dalam pengalaman Anda.
#### [Menonton](#menonton)
Jendela Menonton memiliki dua tab: Variabel dan Jam Tangan Saya .Tab Variabel menunjukkan informasi tentang variabel saat ini dalam lingkup, dan tab Jam Tangan Saya menunjukkan nilai variabel atau ekspresi yang Anda definisikan.Kedua tab menampilkan informasi sebelum baris dieksekusi.
Tab Variabel memiliki kolom berikut:
* Nama \- Nama yang diumumkan dari variabel.
* Scope \- Scope variabel: di mana bisa "dilihat" dan diakses, seperti Lokal, Global, atau Upvalue.
* Nilai \- Nilai saat ini dari variabel.
* Jenis Data \- Jenis data variabel.
Tab Jam Tangan Saya memiliki kolom berikut:
* Ekspresi \- Ekspresi yang ingin Anda tonton.
* Nilai \- Nilai saat ini dari ekspresi.
* Tipe Data \- Tipe data dari ekspresi.
Di tab Variabel , Anda dapat menyaring cakupan variabel dengan mengklik ikon filter.Anda juga dapat mengurutkan baris dengan mengklik nama kolom untuk disortir.Jendela jam menyediakan pandangan yang diperluas dan tertutup dari tabel.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Watch-Window-Variables.png' alt='Watch Window with variable values' title='' width='474px' height='' />Untuk memeriksa kode di jendela Tonton:
1. Jika jendela Tonton tidak terbuka, maka klik Tonton di tab [Lihat](/docs/id-id/studio/view-tab).
2. Ketika sesi pengujian Anda berhenti di titik istirahat, pikirkan bagaimana Anda mengharapkan baris saat ini untuk mengubah nilai variabel dalam skrip tersebut.
3. Saat Anda melangkah melalui kode, perhatikan bagaimana nilai variabel berubah di tab Variabel .Jika Anda ingin menonton ekspresi yang tidak ada di tab Variabel, buka tab Jam Tangan Saya .Klik baris kosong di kolom Ekspresi, lalu ketik ekspresi ke dalamnya.Jika Anda ingin menonton variabel di Editor Skrip, klik dua kali nama variabel, klik kanan, lalu klik Tambahkan Pengawas .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Watch-Window-My-Watches.png' alt='' title='' width='474px' height='' />
4. Bandingkan nilai variabel dan ekspresi dari apa yang Anda harapkan dan apa yang Anda lihat di jendela Tonton.Jika ada perbedaan antara bagaimana Anda mengharapkan variabel untuk berubah dan bagaimana sebenarnya mereka berubah, maka variabel atau fungsi yang berinteraksi dengan mereka mungkin menyebabkan masalah atau bug.
#### [Tumpukan Panggilan](#tumpukan-panggilan)
Jendela Tumpukan Panggilan menunjukkan baris kode mana yang akan dieksekusi berikutnya saat debugger mencapai titik istirahat.Tumpukan Panggilan menunjukkan baris mana yang Anda panggil fungsi dari dan, jika Anda memanggil fungsi di fungsi lain, urutan panggilan fungsi dan baris mana yang memanggil fungsi lain.Fungsi teratas dari Tumpukan Panggilan adalah yang terakhir dipanggil dan pertama dieksekusi.Anda dapat menggunakan Tumpukan Panggilan untuk memeriksa apakah urutan panggilan fungsi di skrip Anda sesuai dengan model mental panggilan fungsi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Call-Stack.png' alt='Call Stack in Studio' title='' width='474px' height='' />Jika Anda memiliki beberapa titik pemutusan di berbagai skrip, mereka mungkin akan menghentikan sesi tes permainan pada saat yang sama.Anda dapat melompat ke titik istirahat dengan mengklik panah di sebelah nama skrip di jendela Stack Panggil.Jika Anda mengklik Lanjutkan , maka Anda melangkah melewati semua titik istirahat yang berhenti pada saat yang sama.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Call-Stack-Multiple-Breakpoints.png' alt='Call Stack with multiple breakpoints' title='' width='474px' height='' />Untuk memeriksa kode di jendela Stack Panggil selama sesi debugging:
1. Jika jendela Tumpukan Panggilan tidak terbuka, maka klik Tumpukan Panggilan di tab [Tampilan](/docs/id-id/studio/view-tab).
2. Saat pengalaman Anda berhenti di titik istirahat, pikirkan tentang bagaimana Anda mengharapkan urutan panggilan fungsi berada di skrip itu.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Script-Editor-Breakpoint-Two-Functions.png' alt='Script Editor with two functions and one breakpoint' title='' width='430px' height='' />
3. Tumpukan Panggilan menunjukkan urutan panggilan fungsi.Jika titik istirahat berada di dalam fungsi, Stack Panggilan menunjukkan fungsi mana yang memanggil fungsi itu, jika ada.Tumpukan Panggilan juga menunjukkan nama dan nomor baris setiap fungsi.Klik baris untuk fungsi untuk melompat ke sana.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Call-Stack-Jump.png' alt='Click in Call Stack to jump to line' title='' width='474px' height='' />
4. Bandingkan urutan panggilan fungsi yang Anda pikirkan di langkah 2 dan urutan aktual dari langkah 3\.Jika ada perbedaan, maka ada perbedaan antara bagaimana Anda mengharapkan kode untuk berperilaku dan bagaimana sebenarnya berperilaku, sehingga menyebabkan masalah dan bug potensial.
#### [Output](#output)
Jendela [Keluaran](/docs/id-id/studio/output) yang dapat diakses dari tab [Pandangan](/docs/id-id/studio/view-tab), menampilkan kesalahan yang ditangkap dari menjalankan skrip, pesan dari Roblox Engine, pesan dari panggilan ke print() , dan kesalahan dari panggilan ke warn() .
#### [Editor Naskah](#editor-naskah)
Debugger terintegrasi dengan [Editor Skrip](/docs/id-id/studio/script-editor).Ketika pengalaman Anda berhenti di titik istirahat dalam skrip, Anda dapat mengarahkan mouse Anda ke nama variabel untuk melihat nilainya.Sebagai contoh, Anda dapat melihat nilai tabel yang Anda berikan sebagai argumen dalam panggilan fungsi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Script-Editor-Mouseover-Table.png' alt='Mouseover a variable in Script Editor to show value' title='' width='700px' height='' />
## [Konfigurasi titik patah](#konfigurasi-titik-patah)
Anda dapat mengonfigurasi titik istirahat untuk hanya pecah jika kondisi tertentu dipenuhi, untuk mencetak pesan ke jendela [Output](#output), dan untuk dijalankan hanya pada klien atau server.Anda juga dapat mencampur konfigurasi ini bersama\-sama untuk memenuhi kebutuhan debugging Anda.
### [Edit titik pemutus](#edit-titik-pemutus)
Anda dapat mengedit konfigurasi titik istirahat kapan saja, termasuk selama sesi pengujian.Jika Anda mengedit titik istirahat selama sesi pengujian, perubahan tersebut bertahan bahkan setelah Anda menyelesaikannya.Anda juga dapat mengedit titik istirahat yang sedang menghentikan sesi pengujian Anda, tetapi perubahan tidak berlaku sampai sesi pengujian berikutnya.
Untuk mengedit konfigurasi titik istirahat:
1. Klik kanan titik pemutus, lalu klik Edit Titik Pemutus .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Gutter-Right-Click-Edit-Breakpoint.png' alt='Right click to edit a breakpoint in Studio' title='' width='320px' height='' />
2. Di jendela Edit Breakpoint , konfigurasi titik pemutus seperti yang Anda inginkan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Edit-Breakpoint-Window.png' alt='Edit Breakpoint window in Studio' title='' width='472px' height='' />
#### [Kondisi, pesan log, dan opsi](#kondisi-pesan-log-dan-opsi)
Untuk setiap titik istirahat, Anda dapat mengatur Kondisi nya, Pesan Log , Lanjutkan Eksekusi , dan Konteks .
Kondisi adalah ekspresi yang menentukan apakah titik istirahat diaktifkan.Kondisi adalah opsional.Jika Kondisi kosong, titik istirahat selalu diaktifkan.Jika Kondisi ada, maka titik istirahat hanya diaktifkan jika kondisi benar.Sebagai contoh, jika Anda ingin titik istirahat hanya diaktifkan jika variabel n sama dengan 42, maka atur Kondisi sebagai n \=\= 42 .Kondisi berguna untuk mendeteksi bagaimana fungsi dieksekusi ketika variabel tertentu memiliki nilai tertentu atau jika Anda ingin mematahkan hanya pada eksekusi tertentu dalam loop.
Pesan Log adalah ekspresi yang dicetak ke jendela [Output](#output) saat kondisi benar.Format Pesan Log adalah sama dengan argumen untuk pernyataan print() .Sebagai contoh, atur Pesan Log sebagai "The value of n:", n untuk mencetak pesan yang sama dengan print("The value of n:", n) .Anda dapat menambahkan dan menghapus Pesan Log tanpa harus menghentikan eksekusi, tidak seperti pernyataan cetak.
Opsi Lanjutkan Eksekusi menentukan apakah titik istirahat menghentikan skrip jika diaktifkan.Berguna jika Anda ingin melogikan nilai variabel atau ekspresi tanpa menghentikan eksekusi.Opsi ini dinonaktifkan secara default.
Konteks dari titik pemutusan menentukan apakah titik pemutusan harus diaktifkan di Klien, Server, atau Edit.Jika konteks adalah Klien, maka titik pemutus di skrip sisi klien.Jika konteks adalah Server, maka titik istirahat diaktifkan dalam skrip sisi server.Jika konteksnya Edit, maka titik pemutus terpicu saat Anda mendepurasi plugin.Jika Anda mengklik Konteks Kustom, jendela menunjukkan konteks saat ini.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Edit-Breakpoint-Window-Custom-Context.png' alt='Edit Breakpoint Window shows Custom Context' title='' width='472px' height='' />
#### [Breakpoint dan logpoin kondisional](#breakpoint-dan-logpoin-kondisional)
Studio menawarkan variasi nama dari titik pemutusan untuk membuat pemutusan titik lebih cepat.Untuk menyisipkan variasi bernama, klik kanan margin ke sebelah kanan nomor barisnya, lalu klik varian yang ingin Anda sisipkan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Gutter-Right-Click-Insert-Breakpoint.png' alt='Right click to insert a breakpoint' title='' width='320px' height='' />A Titik pemutus kondisional adalah titik pemutus dengan kondisi dan eksekusi lanjutan dinonaktifkan.Breakpoint kondisional membekukan skrip Anda hanya jika kondisi benar, jadi mereka berguna untuk mendeteksi bagaimana fungsi dieksekusi ketika variabel tertentu memiliki nilai tertentu.Breakpoint kondisional menggunakan nilai variabel sebelum baris dieksekusi.Ketika Anda menyisipkan Titik Pemutus Kondisional, kursor Anda fokus pada opsi Kondisi untuk Anda atur dengan cepat.
Sebuah Titik Log adalah titik istirahat dengan Pesan Log dan Eksekusi Teruskan diaktifkan.Logpoints mengirim pesan ke jendela [Output](#output) tanpa menghentikan skrip Anda, sehingga berguna untuk mendeteksi nilai variabel.Logpoints menggunakan nilai variabel sebelum baris dieksekusi.Ketika Anda menyisipkan Logpoint, kursor Anda fokus pada Pesan Log untuk Anda atur dengan cepat.
### [Nonaktifkan titik pemutus](#nonaktifkan-titik-pemutus)
Ada banyak cara untuk menonaktifkan dan mengaktifkan kembali titik pemutusan:
* Klik ikon titik pemutus.
* Edit titik istirahat dan beralih kotak centang Diaktifkannya.
* Klik kanan ikon titik istirahat dan klik Nonaktifkan Titik Istirahat atau Aktifkan Titik Istirahat.
### [Hapus titik pemutus](#hapus-titik-pemutus)
Untuk menghapus titik pemutus, klik tengah ikonnya. Anda juga dapat mengklik kanan ikonnya dan klik Hapus Titik Pemutus .
Menghapus titik istirahat menghapus Kondisi dan Pesan Lognya.Jika Anda ingin menyimpan Kondisi atau Pesan Log untuk debugging masa depan, nonaktifkan titik pemutus sebagai gantinya.
### [Jendela titik patah](#jendela-titik-patah)
Jendela Titik Pemutus menunjukkan semua titik pemutus dalam pengalaman Anda.Untuk membuka jendela Titik Pemutus, klik tab Tampilan di bagian atas Studio, lalu klik Titik Pemutus.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Breakpoints-Window.png' alt='Breakpoints window in Studio' title='' width='443px' height='' />Jendela Titik Pemutus memiliki kolom berikut: tidak diberi label, Skrip, Baris, Garis Sumber, Kondisi, Pesan Log, dan Lanjutkan Eksekusi.Kolom Tidak Ber label, Skrip, dan Garis selalu ditampilkan, tetapi Anda dapat menyalakan kolom lain dengan mengklik tiga titik di sudut kanan atas jendela.
Di kolom tanpa label, label (x3\) menunjukkan jumlah titik pemutus pada baris kode yang sama, dan ikon menunjukkan konfigurasi titik pemutus.Titik istirahat pada baris yang sama berbagi Kondisi, Pesan Log, dan Lanjutkan Eksekusi yang sama tetapi bervariasi dalam konteks.Anda dapat mengedit konfigurasi titik istirahat di jendela Titik Istirahat.Sebagai contoh, Anda dapat mengedit Kondisi titik pemutus dengan mengedit bidang teks di kolom Kondisinya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Breakpoints-Window-Edit-Condition.png' alt='Edit the Condition of a Breakpoint in the Breakpoints Window' title='' width='443px' height='' />Anda dapat mengaktifkan dan menonaktifkan titik pemutus dengan mengklik ikon titik pemutusnya di kolom Aktif.Anda juga dapat mengklik tombol berikut untuk mengaktifkan, menonaktifkan, dan menghapus beberapa atau semua titik patah.
| Tombol | Tindakan |
| --- | --- |
| Button to disable all breakpoints | Nonaktifkan semua titik pemutus. Jika titik pemutus manapun dinonaktifkan, aktifkan semuanya. |
| Button to delete all breakpoints | Hapus semua titik patah. |
### [Ikon titik patah](#ikon-titik-patah)
Ikon titik pemutus tergantung pada apakah itu diaktifkan, memiliki kondisi, dan memiliki pesan log.Jika titik istirahat memiliki pesan log, maka tampak sebagai titik log terlepas dari apakah ia memiliki kondisi atau tidak.
| Nama | Ikon | Diaktifkan | Kondisi | Pesan Log |
| --- | --- | --- | --- | --- |
| Titik Patah | | Ya | Tidak | Tidak |
| | | Tidak | Tidak | Tidak |
| Pos Pemutus Kondisi | | Ya | Ya | Tidak |
| | | Tidak | Ya | Tidak |
| Titik Log | | Ya | Mungkin | Ya |
| | | Tidak | Mungkin | Ya |
## [Alat debugging tambahan](#alat-debugging-tambahan)
Selain debugger, Studio menawarkan alat debugging tambahan untuk Anda memperbaiki masalah dan bug di pengalaman Anda.
### [Bar Perintah](#bar-perintah)
Bar perintah memungkinkan Anda menjalankan perintah Luau saat pengalaman sedang berjalan.Ini tersedia di Studio dari tab Pandangan dan di [Konsol Pengembang](/docs/id-id/studio/developer-console).
### [Konsol Pengembang](#konsol-pengembang)
Konsol Pengembang memberikan berbagai rincian termasuk output klien dan server, penggunaan memori, kinerja jaringan, dan banyak lagi .Untuk membuka Konsol Pengembang saat menguji atau memainkan pengalaman, ketik /console ke dalam obrolan atau tekan F9 .Untuk informasi lebih lanjut, lihat [Konsol Pengembang](/docs/id-id/studio/developer-console).
### [File log](#file-log)
Ketika skrip dicetak atau terjadi kesalahan di Studio atau aplikasi Pemutar, aplikasi mencatat pesan dalam file log di sistem file lokal.File\-file ini terletak di tempat yang berbeda tergantung pada sistem operasi.
#### [Jendela](#jendela)
Untuk mengakses file log di Windows:
1. Buka Penjelajah File .
2. Navigasikan ke direktori %LOCALAPPDATA%\\Roblox\\logs .
3. Klik dua kali pada log untuk membukanya. Log dengan nilai yang sama XXXXX berasal dari sesi Studio yang sama.
#### [Makan Mac](#makan-mac)
Untuk mengakses file log di Mac:
1. Buka Pencari .
2. Di bilah menu, pilih Pergi ⟩ Pergi ke Folder... .
3. Di dialog, masukkan \~/Library/Logs/Roblox .
4. Klik dua kali hasil untuk menavigasi ke direktori log Roblox.
5. Di dalam direktori, klik dua kali pada log untuk membukanya.
#### [iOS](#ios)
Anda dapat mengumpulkan log iOS menggunakan Mac atau menggunakan perangkat iOS.
Makan Mac
Perangkat iOS
Untuk mengakses file log iOS di Mac:
1. Hubungkan perangkat iOS ke Mac.
2. Buka Pencari .
3. Navigasikan ke Layanan dan buka aplikasi Konsol .
4. Untuk mengisi log waktu nyata di aplikasi Konsol, pilih perangkat iOS dari bilah sisi, klik tombol Mulai dan reproduksi masalah di perangkat iOS.
5. Untuk mengisi log arsip di aplikasi Konsol, jalankan sudo log collect \-\-device\-name "\[iOS Device Name]" di Terminal .Pastikan tidak ada apostrof dalam nama perangkat atau Anda mungkin mendapatkan kesalahan saat menjalankan perintah.
#### [Android](#android)
Untuk mengakses file log di Android:
1. Navigasikan ke Pengaturan \> Sistem \> Opsi pengembang .
2. Toggle Opsi pengembang pada.
3. Di komputer, unduh dan instal [Android Studio](https://developer.android.com/studio).
4. Di Android Studio, klik Logcat .
5. Hubungkan perangkat Android ke komputer untuk secara otomatis mengisi Logcat dengan log.
| 34 |
https://create.roblox.com/docs/id-id/studio/testing-modes
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Mode pengujian studio
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/testing-modes).
Karena model klien\-server dasar [dari Roblox Engine](/docs/id-id/projects/client-server), penting bagi Anda untuk menguji pengalaman Anda dalam berbagai mode sebelum [merilisnya ke publik](/docs/id-id/production/publishing/publish-experiences-and-places#release-to-the-public).Semua opsi pengujian dapat diakses dari tab [Tes](/docs/id-id/studio/test-tab).
## [Opsi pengujian playtest](#opsi-pengujian-playtest)
Ada tiga opsi umum untuk pengujian pengalaman.Mengklik panah kecil di bawah tombol utama memungkinkan Anda memilih dari setiap opsi, dan menetapkan opsi itu sebagai default.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Playtest-Options.png' alt='Rapid playtest options in Studio.' title='' width='760' height='' />
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Mainkan | F5 | Memulai simulasi pengalaman, menyisipkan avatar Anda di [SpawnLocation](/docs/id-id/reference/engine/classes/SpawnLocation) atau koordinat sekitar (0, 100, 0\). |
| Bermain di Sini | | Memulai simulasi pengalaman, menyisipkan avatar Anda di depan posisi kamera saat ini. |
| Jalankan | F8 | Memulai simulasi pengalaman tetapi tidak menyisipkan avatar Anda.Simulasi dimulai dari posisi kamera saat ini dan Anda dapat bernavigasi di sekitar menggunakan kendalikamera Studio. |
Setelah tes permainan dijalankan, opsi berikut menjadi tersedia:
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Running-Options.png' alt='Additional options available during playtesting in Studio.' title='' width='810' height='' />
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Klien / Server | | Selama pengujian permainan dalam mode "bermain sendiri" ( Bermain atau Bermain di sini ), beralih antara mode Klien dan mode Server .Lihat [Klien/Server Toggle](/docs/id-id/studio/testing-modes#clientserver-toggle) untuk rincian. |
| Pause Fisika / Lanjutkan Fisika | | Memungkinkan Anda [jeda dan lanjutkan fisika](#pause--resume-physics) tanpa menonaktifkan rendering. |
| Berhenti | ShiftF5 | Menghentikan simulasi pengalaman dan mengatur ulang semua objek dan instans ke bagaimana mereka sebelum Bermain , Bermain di sini , atau Jalankan diklik. |
### [Aktifkan klien/server](#aktifkan-klienserver)
Saat menguji dalam mode Mainkan atau Mainkan di sini , Studio menjalankan dua simulasi terpisah — satu simulasi klien dan satu simulasi server — yang dapat memberikan kesan yang lebih akurat tentang bagaimana pengalaman akan dieksekusi dalam produksi.
Saat bermain solo, Anda dapat beralih antara Klien dan Server mode dengan mengklik tombol toggle Klien/Server .Ketika Anda beralih, tombol berubah untuk mencerminkan mode simulasi saat ini.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Client-Server-Toggle.png' alt='Client/Server toggle button indicated in Test tab' title='' width='680' height='' />
#### [Kontrol dan kamera](#kontrol-dan-kamera)
Tergantung pada mode, kontrol karakter Anda dan perubahan kamera sebagai berikut:
Mode Klient
Mode Server
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Client-Server-Toggle-3D-Client.jpg' alt='' title='' width='800' height='450' />
*Dalam mode Klien mode, jendela pandang 3D dikelilingi oleh batas biru dan simulasi menggunakan kontrol karakter dan pengaturan kamera.Mode pengujian ini adalah simulasi dekat dari pengalaman yang berjalan di aplikasi Roblox, tanpa banyak pemain.*
#### [Jendela explorer](#jendela-explorer)
Dalam hierarki jendela [Explorer](/docs/id-id/studio/explorer), beberapa objek hanya ada di wadah yang diharapkan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Client-Server-Toggle-Explorer-Client.png' alt='Explorer window showing items that exist on client only' title='' width='320' height='' />
*Dalam mode Klien , objek klien yang diharapkan hadir dalam hierarki, termasuk yang disalin dari [StarterPack](/docs/id-id/reference/engine/classes/StarterPack) ke pemain [Backpack](/docs/id-id/reference/engine/classes/Backpack) dan dari [StarterPlayer](/docs/id-id/reference/engine/classes/StarterPlayer) ke pemain [PlayerScripts](/docs/id-id/reference/engine/classes/PlayerScripts) .*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/debugging/Client-Server-Toggle-Explorer-Server.png' alt='Explorer window showing items that exist on server only' title='' width='320' height='' />
*Dalam mode Server , objek server yang diharapkan hadir dalam hierarki, termasuk skrip di [ServerScriptService](/docs/id-id/reference/engine/classes/ServerScriptService) dan objek yang Anda tempatkan di [ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage) .*
#### [Output](#output)
Di jendela [Output](/docs/id-id/studio/output), pesan diberi label biru (klien) atau hijau (server), menunjukkan asalnya dari klien atau server.Untuk pesan output dari [ModuleScripts](/docs/id-id/reference/engine/classes/ModuleScript) , warna label ditentukan oleh apakah modul dipanggil dari sisi klien [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) atau dari sisi server [Script](/docs/id-id/reference/engine/classes/Script) .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Output-Window-Client-Server-Labels.png' alt='Output window showing green label for server output and blue label for client output' title='' width='800' height='' />
### [Jeda dan lanjutkan fisika](#jeda-dan-lanjutkan-fisika)
Sementara [pengujian permainan](#playtest-options) , tombol Pause Fisika dan Lanjutkan Fisika berguna untuk mendiagnosis adegan dan mekanisme ephemeral, tanpa menonaktifkan rendering.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Pause-Resume-Physics.png' alt='Pause Physics and Resume Physics buttons available during playtesting in Studio.' title='' width='810' height='' />Secara default, menghentikan dan melanjutkan tindakan fisika terhadap klien dan server sebagaimana ditunjukkan oleh notasi Semua .Jika Anda ingin menghentikan atau melanjutkan hanya fisika klien atau server, klik panah kecil di tombol mana pun dan pilih Saat ini .Kemudian, tergantung pada pandangan yang dipilih melalui tombol Client/Server pause atau resume hanya akan bertindak pada sisi simulasi itu.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Pause-Resume-Physics-All-Current.png' alt='Selection arrows for Pause Physics and Resume Physics to toggle between All or Current pause/resume action between client and server physics.' title='' width='810' height='' />Ketika fisika dijeda, Anda dapat melangkah maju 1/60 detik (60 Hz) dengan mengklik tombol Langkah Maju Fisika .Seperti tombol tetangga di sebelah kirinya, mengklik panah kecil memungkinkan Anda beralih antara langkah klien dan/atau server antara Semua atau Saat ini .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Step-Forward-Physics.png' alt='Step Forward Physics button available during playtesting in Studio, only active while physics is paused.' title='' width='810' height='' />Perhatikan rincian teknis berikut dalam kaitannya dengan jeda/lanjutkan fisika:
* Meskipun [Animations](/docs/id-id/reference/engine/classes/Animation) tidak didasarkan pada fisika, tombol bilah alat ini juga membekukan/melanjutkan animasi.
* Mematikan atau melanjutkan fisika tidak memiliki efek pada menjalankan skrip.
* Hanya panggilan balik , , , dan berhenti atau melanjutkan melalui tombol bilah alat ini.Panggilan balas lainnya ( [PreRender](/docs/id-id/reference/engine/classes/RunService#PreRender) , [Heartbeat](/docs/id-id/reference/engine/classes/RunService#Heartbeat) , dan [RenderStepped](/docs/id-id/reference/engine/classes/RunService#RenderStepped) ) terus menembak, mempertahankan fungsionalitas normal dari skrip kamera, visualisasi yang diterjemahkan, dan plugin.
## [Simulasi multi\-klien](#simulasi-multi-klien)
Menggunakan opsi klien dan server , Anda dapat meluncurkan beberapa sesi Studio, satu bertindak sebagai server dan masing\-masing bertindak sebagai klien.Mode pengujian ini adalah alat berharga untuk membandingkan bagaimana klien "melihat" klien lain dalam pengalaman.
1. Pastikan Server Lokal dipilih di kotak atas, lalu pilih jumlah sesi pemain untuk diuji.Biasanya 1–2 pemain sudah cukup, meskipun Anda dapat menyimulasikan hingga delapan.
2. Tekan tombol Mulai untuk memulai simulasi klien\-server.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Clients-Servers-Start.png' alt='Clients and Servers simulation setup indicated in Test tab' title='' width='760' height='' />
3. Saat Anda selesai menguji, tekan tombol Bersihkan dari salah satu sesi simulasi untuk menutup semua klien simulasi dan server simulasi.
## [Pengujian bersama](#pengujian-bersama)
Jika Anda bekerja pada pengalaman dengan orang lain dalam mode [Kolaborasi](/docs/id-id/projects/collaboration), Anda dapat menguji dengan pencipta lain sebagai berikut:
1. Pilih Tes Tim di kotak atas dan tekan tombol Mulai untuk mempublikasikan status saat ini dari pengalaman dan membuat sesi Studio baru dengan karakter Anda dimasukkan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Clients-Servers-Team-Test.png' alt='Team Test setup indicated in Test tab' title='' width='760' height='' />
2. Kolaborator lain kemudian dapat bergabung dengan menekan Bergabung dari tab Tes .
Hanya satu sesi tes tim yang dapat dijalankan pada waktu tertentu. Untuk menutup sesi dan mengusir semua penguji, klik tombol Tutup Server .
## [Emulasi perangkat](#emulasi-perangkat)
Emulator Perangkat memungkinkan Anda untuk meniru berbagai perangkat langsung di Studio, memberikan wawasan tentang bagaimana kontrol bekerja di perangkat seluler, konsol, dan headset VR, serta bagaimana elemen UI di layar ditampilkan pada resolusi dan rasio aspek yang berbeda.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Emulation-Device.png' alt='Device button indicated in Test tab' title='' width='800' height='' />Di mode emulasi, Anda dapat memilih perangkat dari menu dropdown pemilih perangkat di atas jendela pandang 3D untuk meniru perangkat yang kurang kuat dan menguji [pengalaman streaming yang diaktifkan](/docs/id-id/workspace/streaming) di mana konten 3D dinamis memuat dan melepaskan berdasarkan memori yang tersedia.Anda juga dapat menyesuaikan ukuran pandangan dan mengubah orientasi antara mode lanskap dan potret.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Editor-Window-Emulation-Options.png' alt='Emulation options above the 3D viewport' title='' width='840' height='' />
## [Emulasi kontroler](#emulasi-kontroler)
The Emulator Kontroler memungkinkan Anda untuk secara akurat meniru input gamepad langsung di StudioKontroler default adalah gamepad umum, tetapi Anda dapat memilih alternatif untuk perangkat PlayStation, Xbox, dan Quest dari menu pemilih kiri atas.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Emulation-Controllers.png' alt='Emulate Device Controllers button indicated in Test tab' title='' width='840' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Controller-Emulator.png' alt='View of the generic controller in the Controller Emulator.' title='' width='720' height='' />Selama pengujian permainan, Anda dapat mengontrol pengalaman dengan kontroler virtual menggunakan mouse Anda.
Anda juga dapat mengklik Edit mappings di sudut kanan atas untuk melihat dan mengedit peta kunci untuk kontrol virtual, misalnya E untuk [ButtonL2](/docs/id-id/reference/engine/enums/KeyCode#ButtonL2) atau 9 untuk [ButtonA](/docs/id-id/reference/engine/enums/KeyCode#ButtonA) .Peta ini disimpan seperti pengaturan Studio lainnya (per kontroler, per pengguna, per komputer) dan diterjemahkan ke acara gamepad di jendela emulator dan tampilan 3D.
## [Simulasi VR](#simulasi-vr)
Emulasi VR memungkinkan Anda menguji pengalaman VR di Studio tanpa headset fisik.Sama seperti memulai ulang perangkat lain, gunakan menu [pemilih perangkat](#device-emulation) untuk memilih Meta Quest 2 atau Meta Quest 3 .Emulator kontrolir [memilih kontrolir yang tepat untuk headset secara otomatis](#controller-emulation).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Controller-Emulator-VR.png' alt='The Controller Emulator with a Quest 3 controller.' title='' width='540' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Emulator-Viewport-VR.jpg' alt='Emulator with a Quest 3 emulation.' title='' width='716' height='' />Kombinasi headset dan banyak kontroler, masing\-masing dengan pelacakan gerakan, membuat emulasi VR lebih rumit:
* Untuk emulasi pelacakan gerakan, tekan Alt1 ( ⌥1 ) untuk mengunci mouse dan membuka kunci mouse dari jendela pandang.
* Gunakan Shift← atau Shift→ untuk beralih di antara kombinasi umum dari headset, kontroler, dan kontroler.Sebagai contoh, Anda mungkin menggunakan opsi Headset untuk melihat sekeliling saat Anda berjalan maju dengan tombol kontrol kiri, tetapi kemudian beralih ke Kontrol Kanan ketika Anda perlu menggunakan kontrol gerakan untuk menargetkan target.
## [Headset VR](#headset-vr)
Jika Anda ingin mendukung headset virtual reality (VR) untuk pengalaman Anda, pastikan untuk menguji atau [memulai ulang](#vr-emulation) VR di Studio.Studio mendukung pengujian untuk semua headset VR yang kompatibel dengan [OpenXR](https://www.khronos.org/openxr/), standar industri open source yang memberikan akses ke VR.
Saat ini, pengujian di VR hanya didukung di Windows.
### [Konfigurasi headset](#konfigurasi-headset)
Untuk mengaktifkan pengujian Studio di VR, Anda harus menghubungkan headset Anda ke PC Anda dan mengkonfigurasi runtime OpenXR sebelum meluncurkan Studio .Jika Anda sudah meluncurkan Studio, berhenti dan selesaikan langkah konfigurasi terlebih dahulu.
Jika Anda hanya memiliki satu headset VR, menginstal aplikasi VR yang sesuai secara otomatis mengkonfigurasi runtime untuk Anda.Jika Anda memiliki beberapa headset, Anda harus mengatur runtime secara manual dan memastikan untuk hanya mengkonfigurasi yang ingin Anda gunakan untuk pengujian.
Langkah berikut adalah untuk dua aplikasi VR paling umum:
* SteamVR untuk headset seperti HTC Vive dan Valve Index.
* Oculus untuk headset seperti Meta Quest dan Oculus Rift.
VR Steam
Oculus VR
1. Instal dan buka aplikasi SteamVR di komputer Anda.
2. Di bawah Pengaturan SteamVR , pilih tab Pengembang . Kemudian pilih Tampilkan Pengaturan Lanjutan .
3. Atur SteamVR sebagai runtime OpenXR.
4. Nyalakan kontroler dengan menekan tombol Sistem sampai Anda mendengar suara beeping.
* Untuk mematikan kontroler, tekan dan tahan tombol Sistem sampai Anda mendengar suara beeping yang sama.
Jika Anda mengikuti langkah\-langkah dengan benar, ikon status di aplikasi SteamVR dan lampu status di hardware semua harus hijau, menunjukkan bahwa konfigurasi selesai.
Ketika Anda keluar dari aplikasi SteamVR, kontroler secara matikan.Kontroler juga secara otomatis mati setelah tidak aktif selama periode waktu.
### [Aplikasi Pencarian Roblox](#aplikasi-pencarian-roblox)
Anda dapat menguji pengalaman Anda di aplikasi Roblox di Quest tanpa menghubungkan headset Anda ke komputer Anda.Gunakan langkah berikut untuk mengakses pengalaman Anda di headset dalam mode ini:
1. Di Studio, publikasikan pengalaman dan atur pengalaman ke privat.
2. Menggunakan [Dashboard Pencipta](https://create.roblox.com/dashboard/creations) Anda atau tautan di Studio, buka halaman pengalaman di browser web Anda.
3. Di halaman pengalaman, tambahkan pengalaman ke favorit Anda dengan mengklik ikon Favorit .
4. Menggunakan headset Anda, buka aplikasi Roblox berdiri sendiri.
5. Gulir ke bawah ke bagian Favorit di halaman utama dan jalankan pengalaman Anda.
### [Mode VR Studio](#mode-vr-studio)
Setelah [mengkonfigurasi headset Anda](#headset-configuration) , Anda dapat menyalakan mode pengujian VR Studio melalui langkah berikut:
1. Di menu File , pilih Pengaturan Studio .
2. Pilih Rendering .
3. Di bawah Umum pengaturan, nyalakan Mode VR .
Anda sekarang dapat menguji pengalaman Anda menggunakan headset VR Anda menggunakan salah satu opsi pengujian [playtest](#playtest-options) yang tersedia.Selama sesi pengujian VR, jika kabel headset Anda terputus atau Anda menutup aplikasi Roblox Studio Beta di headset, Anda perlu memulai ulang Studio untuk menjalankan uji coba lagi.
## [Emulasi pemain](#emulasi-pemain)
Untuk emulasi pengalaman terperinci [lokalisasi](/docs/id-id/production/localization) dan kebijakan konten, Anda dapat menguji melalui emulator Pemutar .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Emulation-Player.png' alt='Player emulator button indicated in Test tab' title='' width='840' height='' />Dengan jendela emulator terbuka, beralih pada Aktifkan Profil Tes .Emulasi akan tetap sebagai geser (aktif atau dinonaktifkan) bahkan jika Anda menutup jendela.
Turunkan di jendela, opsi yang umumnya digunakan termasuk:
| Pilihan | Deskripsi |
| --- | --- |
| Lokal | Memungkinkan Anda meniru bahasa [terlokalisasi](/docs/id-id/production/localization) saat menguji permainan. |
| Pseudolokalisasi | Mengganti karakter dengan karakter serupa tetapi sedikit berbeda sehingga mudah untuk mengidentifikasi string mana yang melalui sistem [terjemahan](/docs/id-id/production/localization) .Mengaktifkan ini membantu Anda mengidentifikasi teks tidak terlokalisasi tanpa harus mengubah bahasa emulasi.Sebagai contoh:* Bloxy Cola ⟩ ßℓôж¥ Çôℓá * Dominus Empyreus ⟩ Ðô₥ïñúƨ É₥ƥ¥řèúƨ |
| Memperpanjang | Memperpanjang string teks dengan faktor yang didefinisikan melalui slider. Misalnya:* Bloxy Cola \> Bloooxyy Coolaa (50% lebih lama) * Dominus Empyreus \> Doomiinuus Eempyyreus (30% lebih lama) Memperpanjang string teks dengan faktor yang didefinisikan melalui slider.Sebagai contoh: Menggunakan perpanjangan membantu Anda mengidentifikasi tempat di mana antarmuka pengguna Anda mungkin tidak dapat menangani teks yang lebih panjang dari teks yang diterjemahkan default.Perhatikan bahwa Spanyol rata\-rata 30% lebih lama dari bahasa Inggris dan yang setara untuk Jerman bahkan lebih lama.Perhatikan juga bahwa ini hanya memengaruhi teks yang melalui sistem [terjemahan](/docs/id-id/production/localization). |
| Wilayah | Memungkinkan Anda meniru negara/wilayah pemain saat melakukan pengujian permainan; pilihan ini dapat mempengaruhi tombol geser dan kotak centang lainnya di jendela seperti yang dijelaskan di [GetPolicyInfoForPlayerAsync()](/docs/id-id/reference/engine/classes/PolicyService#GetPolicyInfoForPlayerAsync) . |
| 35 |
https://create.roblox.com/docs/id-id/studio/output
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Jendela hasil
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/output).
Jendela Keluaran yang dapat diakses dari tab [Pandangan](/docs/id-id/studio/view-tab), menampilkan kesalahan yang ditangkap dari menjalankan skrip, pesan dari Roblox Engine, pesan dari panggilan ke print() , dan kesalahan dari panggilan ke warn() .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Output.png' alt='Output button indicated in View tab of Studio' title='' width='768' height='' />Plugin dapat berinteraksi dengan jendela Output melalui [LogService](/docs/id-id/reference/engine/classes/LogService), yang dapat merekam dan menghapus konten jendela Output.Anda dapat menyesuaikan output melalui elemen berikut:
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Output-Window-Diagram.png' alt='Sections of Output window indicated by lettered pointers' title='' width='820' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-A.png' alt='' title='' width='40' height='' />Filter output berdasarkan ketik, seperti Kesalahan atau Peringatan .
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-B.png' alt='' title='' width='40' height='' />Filter output berdasarkan konteks, seperti Klien , Server , atau Plugin Pengguna .
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-C.png' alt='' title='' width='40' height='' />Filter output oleh teks yang dimasukkan ke bidang, seperti nama objek.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-D.png' alt='' title='' width='40' height='' />Menghapus semua pesan output dari jendela. Tindakan ini memiliki pintasan pada Windows atau pada Mac.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-E.png' alt='' title='' width='40' height='' />Mengontrol tingkat rincian yang ditampilkan untuk setiap pesan output.
* Tampilkan Timestamp — Menampilkan timestamp terperinci dalam format HH:MM:SS.SSS.:
* Tampilkan Konteks — Menampilkan konteks pesan, seperti Klien atau Server .:
* Tampilkan Sumber — Jika berlaku, menunjukkan nama dan nomor baris skrip yang terkait.:
* Tampilkan Tabel yang Diperluas Secara Default — Untuk tabel yang dihasilkan, konten diperluas secara default.:
* Tampilkan Alamat Memori untuk Tabel yang Dapat Diperluas — Untuk tabel yang dapat diperluas, tampilkan alamat memori internal, seperti 0xb4f0417581144ec5 .:
* Mode Log — Sederhanakan output dengan menghapus opsi, seperti pohon yang dapat diperluas.
| 36 |
https://create.roblox.com/docs/id-id/studio/microprofiler
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [MicroProfiler](/docs/id-id/studio/microprofiler)
Bahasa Indonesia
Masukan
# Profiler Mikro
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/microprofiler).
The MicroProfiler adalah alat optimisasi kinerja dan troubleshooting yang tersedia di Roblox Studio dan klien Roblox.Ini memberikan informasi waktu terperinci untuk [jadwal tugas](/docs/id-id/studio/microprofiler/task-scheduler) tugas yang disebut tag .
* Untuk daftar tugas umum, referensikan tag [tag referensi](/docs/id-id/studio/microprofiler/tag-table).
* Untuk contoh langkah demi langkah tentang penggunaan MicroProfiler untuk mengidentifikasi masalah kinerja, lihat [panduan MicroProfiler](/docs/id-id/studio/microprofiler/use-microprofiler).
## [Dasar\-dasar Profiler Mikro](#dasar-dasar-profiler-mikro)
Untuk membuka MicroProfiler, tekan CtrlAltF6 ( ⌘⌥F6 ) di Studio atau klien.Anda juga dapat menggunakan menu pengaturan di klien.
Saat terbuka, bilah menu terlihat di bagian atas tampilan 3D.Dalam mode default, grafik bilah bergerak menunjukkan waktu yang digunakan pada setiap frame dari Jadwal Tugas.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-frame.png' alt='The Microprofiler frame graph, showing blue frames and detailed frame information.' title='' width='440px' height='' />Bar umumnya harus berada di sekitar tengah grafik, tetapi Anda mungkin melihat lonjakan tiba\-tiba (peningkatan nilai yang cepat).Spike menunjukkan bahwa lebih banyak waktu diperlukan untuk melakukan beberapa tugas, biasanya karena beban kerja yang meningkat.Sebagai kejadian, membuat banyak bagian bergerak membutuhkan lebih banyak pekerjaan dari simulasi fisika, yang kemudian membutuhkan lebih banyak waktu untuk memproses gerakan dan kontak bagian.Gambar berikut menunjukkan contoh spike:
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-spike.png' alt='The Microprofiler with several bars higher than others.' title='' width='300px' height='' />Untuk menghentikan perekaman frame, tekan CtrlP ( ⌘P ) atau klik Pause di bilah menu.Saat dijeda, garis waktu muncul, dan Anda dapat menavigasi melalui frame dengan mengklik atau seret di grafik.
Untuk ringkasan lengkap tentang berbagai pandangan dan cara menavigasi antarmuka MicroProfiler, lihat [mode MicroProfiler](/docs/id-id/studio/microprofiler/modes).
## [Thread](#thread)
Seperti banyak program, Roblox menggunakan beberapa thread untuk melakukan beberapa urutan tugas pada saat bersamaan.Di MicroProfiler [mode terperinci](/docs/id-id/studio/microprofiler/modes#detailed-mode), Anda dapat melihat label untuk setiap thread di sebelah kiri.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-panning.png' alt='The lefthand side of the Microprofiler detailed view, with rows for threads.' title='' width='440px' height='' />Ada tiga jenis thread utama:
* Utama/Render : Mungkin tidak intuitif, berjalan di CPU.Memproses input, [Humanoids](/docs/id-id/reference/engine/classes/Humanoid) , animasi/tweening, kepemilikan fisika, suara, dan resume skrip tunggu.Juga memperbarui antarmuka Studio dan mengkoordinasikan thread lainnya.
* Pekerja ("Pekerja RBX": Membantu thread utama dengan jaringan, fisika, dan penemuan jalur.Karena jumlah core di CPU modern, Anda mungkin memiliki banyak thread pekerja, sebagian besar di negara tidur pada waktu tertentu.
* Render ("GPU"): Mengikuti logika "siapkan, lakukan, hadirkan". Komunikasikan dengan unit pemrosesan grafis (GPU) perangkat.
+ Siapkan: Informasi dari thread utama digunakan untuk memperbarui model rendering.
+ Lakukan: Lakukan perintah rendering masalah, termasuk antarmuka 2D.
+ Hadir: Sinkronisasi dengan GPU.
## [Profil khusus](#profil-khusus)
Jika skrip Anda menjalankan tugas yang rumit, Anda dapat mengidentifikasi bagian penting dari kode untuk memastikan bahwa mereka tidak terlalu lama.Bungkus kode dalam [debug.profilebegin()](/docs/id-id/reference/engine/libraries/debug#profilebegin) dan [debug.profileend()](/docs/id-id/reference/engine/libraries/debug#profileend) untuk menyelesaikan semuanya antara panggilan fungsi tersebut dan membuat label di timeline MicroProfiler.
```
Skrip Kerja Keras
---
```
debug.profilebegin("Hard Work")
-- Kode untuk diprofilkan
debug.profileend()
```
```
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-profiled.png' alt='A custom label on the detailed view of the MicroProfiler.' title='' width='300px' height='' />Ada jumlah memori terbatas yang tersedia untuk label MicroProfiler.Jika memori ini kehabisan, label profiler khusus mungkin tidak muncul sebagai nama yang berarti di timeline.Gunakan label lebih sedikit untuk menghindari masalah ini.Jika Anda tidak lagi perlu memprofilkan bagian kode Anda, komentari atau hapus panggilan ke fungsi ini.
### [Contoh](#contoh)
Sampel kode di bawah ini menghubungkan fungsi dummy ke acara [RunService.PreSimulation](/docs/id-id/reference/engine/classes/RunService#PreSimulation) , yang berjalan setiap frame.Apa pun yang dilakukan ini sering harus berjalan seefisien mungkin, jadi fungsi ini adalah kandidat yang baik untuk profiling.
```
---
```
local RunService = game:GetService("RunService")
local function onPreSimulation()
debug.profilebegin("Hard Work")
-- Contoh kerja keras: ganti dua variabel 200.000 kali
local a, b = 0, 1
for _ = 1, 200000 do
a, b = b, a
end
debug.profileend()
end
RunService.PreSimulation:Connect(onPreSimulation)
```
```
Ketika Anda menjalankan pengalaman dan membekukan MicroProfiler ( CtrlP atau ⌘P ), label khusus terlihat di bawah label gameStepped .
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-contrived.png' alt='Many labels on the MicroProfiler, with a custom label taking up the majority of the processing time.' title='' width='700px' height='' />Dari durasinya di timeline, Anda dapat mengatakan bahwa fungsi menggunakan banyak waktu pemrosesan dibandingkan dengan operasi lain.
## [Simpan data frame](#simpan-data-frame)
Jika Anda ingin menyimpan serangkaian data frame untuk direvisi nanti (atau untuk dibagikan dengan orang lain), gunakan menu Dump .Mesin menyimpan data frame ke file bernama microprofile\-\<date\>\-\<time\>.html di direktori log Roblox.
* Pada Windows, periksa %LOCALAPPDATA%\\Roblox\\logs .
Jika Anda menggunakan aplikasi Universal Windows Platform (UWP), periksa \\Users\\\<username\>\\AppData\\Local\\Packages\\ROBLOXCORPORATION.ROBLOX\_\<hash\>\\LocalState\\logs\\ .
* Pada macOS, periksa \~/Library/Logs/Roblox.
File HTML ini menggunakan UI berbasis web yang sama sebagai koneksi langsung untuk perangkat seluler dan dump server .
Limbah hanya berisi data untuk jumlah frame yang dipilih, tidak selama seluruh waktu yang pengalaman telah berjalan.Pengecualian adalah [mode penghitung](/docs/id-id/studio/microprofiler/modes#counters-mode) , yang termasuk data dari ketika Studio atau klien mulai berjalan sampai saat dump.
## [Perangkat mobile profil](#perangkat-mobile-profil)
Untuk mengakses MicroProfiler dari klien seluler, perangkat seluler Anda harus terhubung ke jaringan yang sama sebagai mesin pengembangan Anda.
Aktifkan MicroProfiler di menu Pengaturan perangkat seluler. Setelah Anda mengaktifkannya, menu menunjukkan alamat IP dan nomor port.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/6MicroProfiler-Mobile-Enable.jpeg' alt='A picture of the Settings menu on mobile, showing how to enable the MicroProfiler.' title='' width='600px' height='' />Sebagai contoh, dalam tangkapan layar di atas, alamatnya adalah 192\.168\.1\.166 dan portnya adalah 1338 .Dari komputer di jaringan yang sama, navigasikan ke http://192\.168\.1\.166:1338 untuk versi [web\-based](#use-the-web-ui) dari antarmuka pengguna MicroProfiler.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/7MicroProfiler-Browser.jpeg' alt='The MicroProfiler web view.' title='' width='600px' height='' />
## [Profilkan server](#profilkan-server)
Selain klien standar MicroProfiler, Anda dapat mengambil dump singkat dari aktivitas server menggunakan server MicroProfiler.
1. Dalam pengalaman yang Anda miliki izin untuk diedit, buka Konsol Pengembang dengan CtrlAltF9 .
2. Di menu dropdown, pilih MicroProfiler .
3. Di bagian ServerProfiler , spesifikasikan jumlah frame per detik (maksimum 60\) dan jumlah detik untuk diprofil (maksimum 4\).
4. Klik Mulai Rekam .
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-server.png' alt='The Developer Console MicroProfiler screen.' title='' width='800px' height='' />Setelah beberapa detik, Konsol Pengembang memberikan jalur ke file, yang merupakan jalur yang sama dengan dump standar .
## [Gunakan UI web](#gunakan-ui-web)
Secara umum, UI web MicroProfiler berfungsi serupa dengan [mode terperinci](/docs/id-id/studio/microprofiler/modes#detailed-mode) , tetapi memiliki beberapa fitur tambahan:
* Selain menyaring oleh grup, Anda dapat menyaring oleh thread.
* Gunakan CtrlF / ⌘F untuk melompat ke terjadinya tugas yang mengambil sebagian besar waktu di dump.Sebagai contoh, computeLightingPerform berjalan di setiap frame.Jika Anda mencarinya di dump dengan 128 frame, Anda dapat melompat ke frame di mana dibutuhkan waktu terlama untuk menyelesaikannya.
* Gunakan menu X\-Ray untuk mengaktifkan atau menonaktifkan kode warna untuk alokasi memori.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-xray.png' alt='The MicroProfiler web view with x-ray enabled.' title='' width='600px' height='' />
+ Fram lebih ringan di dalam grafik bilah utama menunjukkan alokasi memori yang lebih tinggi.
+ Bagian\-bagian ringan dari bilah pratinjau dan label ringan di timeline menunjukkan bagian frame dengan alokasi memori lebih tinggi.
+ Di mode X\-ray, tekan C untuk menunjukkan ukuran total alokasi memori daripada jumlah alokasi.
* Gunakan menu Ekspor untuk mengekspor grafik api CPU atau memori, grafik visualisasi khusus yang mengumpulkan semua tumpukan panggilan yang termasuk dalam dump, mempertahankan hierarki orangtua\-anak, dan menyesuaikan ukurannya berdasarkan durasi.Grafik api sangat berguna untuk mengidentifikasi tugas yang tidak membutuhkan waktu lama untuk dijalankan (dan karena itu sulit dilihat), tetapi dijalankan begitu sering sehingga waktu pemrosesannya menjadi signifikan.
Anda juga dapat membuat grafik api di Studio, meskipun hanya untuk skrip (waktu eksekusi dan alokasi memori).Dibandingkan dengan grafik api berbasis web, yang ada di Studio berada di atas ke bawah daripada ke bawah dan mendukung waktu penangkapan dramatis lebih lama.
* Seret dan lepaskan file dump kedua ke UI web untuk menghasilkan grafik api perbedaan, yang dapat membantu Anda mengidentifikasi perbaikan atau regresi pada kinerja pengalaman Anda seiring waktu.Klik Gabungkan \& Bandingkan untuk mengekspor file HTML baru.
Anda dapat menggabungkan beberapa file dump \- misalnya, empat di setiap sisi, dari sebelum dan setelah pembaruan besar \- untuk mendapatkan perbandingan yang lebih teraggregasi.Membandingkan data di berbagai tempat juga bisa berguna, tetapi jangan gabungkan data dari berbagai tempat!
Grafik api perbedaan menyoroti dump (kiri atau kanan) yang mengkonsumsi lebih banyak CPU atau memori, dengan warna yang lebih cerah menunjukkan perbedaan yang lebih besar.
| 37 |
https://create.roblox.com/docs/id-id/studio/microprofiler/modes
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [MicroProfiler](/docs/id-id/studio/microprofiler)
Bahasa Indonesia
Masukan
# Mode profiler mikro
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/microprofiler/modes).
MicroProfiler memiliki beberapa mode, yang dapat membantu Anda menggambarkan karakteristik kinerja pengalaman Anda dengan cara yang berbeda.Setelah membuka MicroProfiler dengan CtrlAltF6 ( ⌘⌥F6 ), gunakan menu Mode untuk beralih di antara mereka.
## [Mode frame](#mode-frame)
Mode paling dasar, mode frame menunjukkan grafik bar bilah dari kanan (baru\-baru ini) ke kiri.Tinggi setiap bar menunjukkan jumlah milidetik yang dibutuhkan untuk menyelesaikan frame.Pasangkan di atas frame untuk beberapa informasi dasar tentang penggunaan CPU dan GPU.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-frame.png' alt='The Microprofiler frame graph, showing blue frames and detailed frame information.' title='' width='300px' height='' />* Bar oranye menunjukkan bingkai di mana Jobs Wall Time melebihi Waktu Render Wall .Dalam frame ini, setidaknya salah satu thread pekerja, yang melakukan hal\-hal seperti menjalankan skrip, menghitung fisika, dan memainkan animasi, membutuhkan waktu lebih lama untuk dijalankan daripada thread render utama.
Jika pengalaman tidak mencapai tujuan waktu kerangka Anda dan memiliki banyak frame oranye, penyebab umum adalah skrip, fisika, dan animasi.Lihat [Tingkatkan kinerja](/docs/id-id/performance-optimization/improve#script-computation) .
* Garis biru menunjukkan bingkai di mana Waktu Render Dinding melebihi Waktu Dinding Pekerjaan .Dalam frame ini, thread rendering utama membutuhkan lebih banyak waktu daripada salah satu thread pekerja.
Jika pengalaman tidak mencapai tujuan waktu bingkai Anda dan memiliki banyak bingkai biru, itu menunjukkan penyumbatan rendering.Penyebab umum adalah kepadatan objek yang berlebihan, gerakan objek, dan pencahayaan.Lihat [Tingkatkan kinerja](/docs/id-id/performance-optimization/improve#rendering) .
* Garis merah menunjukkan bingkai di mana dua kondisi benar:
+ Waktu Render Dinding melebihi Waktu Dinding Pekerjaan \* Waktu Tunggu GPU lebih besar dari 2,5 milidetikBilah merah kurang umum daripada oranye dan biru dan seringkali hasil dari kompleksitas objek berlebih, ukuran tekstur, dan efek visual.Optimisasi mirip dengan bar biru.Lihat [Tingkatkan kinerja](/docs/id-id/performance-optimization/improve#rendering) .
Tugas kecil di akhir frame terkadang bisa menghapus Jobs Wall Time dan Render Wall Time , yang merupakan alasan lain untuk lebih fokus pada waktu frame daripada warna frame.Tidak ada warna frame "baik" untuk disimpan.Campuran oranye, biru, dan merah tidak masalah selama Anda mencapai tujuan waktu bingkai untuk pengalaman Anda.Jika Anda tidak mencapai tujuan waktu bingkai Anda, warna dapat menunjukkan di mana harus dioptimalkan.
Mematikan MicroProfiler dengan CtrlP ( ⌘P ) saat berada dalam mode frame meluncurkan mode terperinci .
## [Mode terperinci](#mode-terperinci)
Selain grafik bar dari mode frame, mode terperinci menambahkan garis waktu berwarna yang menunjukkan label untuk setiap tugas.
* Label yang muncul langsung di bawah label lain menunjukkan tugas yang dilakukan sebagai bagian dari tugas tingkat lebih tinggi.
Daripada tugas orangtua, Anda biasanya ingin memecahkan masalah tugas anak terburuk; tugas orangtua tidak bisa lebih pendek dari jumlah tugas anaknya.
* Gulir memperbesar atau memperkecil garis waktu.Dikombinasikan dengan label milidetik di bagian atas garis waktu, Anda dapat mendapatkan gambaran tentang berapa lama waktu yang diperlukan untuk tugas dalam arti absolut, tetapi juga berapa lama waktu yang diperlukan relatif terhadap tugas lain.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/3MicroProfiler-Timeline.jpeg' alt='The Microprofiler detailed view with numerous horizontal labels.' title='' width='440px' height='' />
* Overlay hijau di bagian grafik bar menunjukkan jumlah frame yang saat ini terlihat di timeline \- levelzoom Anda.Klik kiri pada bilah frame untuk melompat ke posisi itu di timeline.
Anda mungkin harus menyesuaikan levelzoom Anda, tetapi menggulir di atas bilah menyoroti bingkai di timeline. Garis abu\-abu muda menentukan bingkai.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-detailed.png' alt='The MicroProfiler bar graph with green overlay to show zoom level.' title='' width='440px' height='' />
* Klik kiri dan seret untuk memindahkan garis waktu.Pada mesin dengan banyak core CPU, Anda mungkin perlu sedikit bergerak ke atas atau ke bawah untuk menemukan thread utama atau thread pekerja yang melakukan tugas tertentu.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-panning.png' alt='The lefthand side of the Microprofiler detailed view, with rows for threads.' title='' width='440px' height='' />
* Klik kanan label untuk memperbesar garis waktu ke persis durasi tugas itu.
* Klik kiri pada label untuk menambahkannya ke grafik garis di kanan bawah.Grafik menunjukkan waktu yang dibutuhkan tugas untuk setiap frame.Menggunakan grafik ini, Anda dapat menguji kinerja hanya tugas tertentu di game Anda.Saat Anda selesai, klik kanan grafik untuk menyembunyikannya.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-graph.png' alt='The graph showing how long tasks take per frame.' title='' width='300px' height='' />Gunakan menu Opsi untuk mengubah garis referensi pada grafik ke nomor milidetik yang berbeda.
* Jika jumlah informasi terlalu banyak, hover di atas label untuk menemukan grup.Kemudian gunakan menu Kelompok untuk menyaring garis waktu ke satu atau lebih kelompok, seperti Fisika atau Render .
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-group.png' alt='The on-hover view for a label, with Group highlighted.' title='' width='360px' height='' />
## [Mode jam tangan](#mode-jam-tangan)
Mode waktu adalah cara alternatif untuk memvisualisasikan data dalam pandangan terperinci: sebagai daftar label dengan waktu pemrosesan dan hitungan panggilan.Grafik bar horizontal di beberapa kolom membantu Anda mendeteksi tugas paling sibuk.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-timer.png' alt='Timers mode.' title='' width='800px' height='' />Kontrol mirip dengan pandangan terperinci:
* Klik kiri dan tahan untuk menggeser ke atas dan ke bawah.
* Klik kiri pada label untuk menambahkannya ke grafik garis di kanan bawah.
* Gunakan menu Kelompok untuk menyaring daftar.
* Gunakan menu Pengatur Waktu untuk menyesuaikan kolom.
Semua informasi dalam pandangan ini terlihat saat Anda mengarahkan kursor ke atas label di pandangan terperinci.
## [Mode penghitungan](#mode-penghitungan)
Mode penghitung adalah daftar panjang kategori dan statistik, termasuk hitungan instansi dan penggunaan memori (dalam bayt) untuk berbagai tugas.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-counter.png' alt='Counters mode with a single graph.' title='' width='800px' height='' />* Sama seperti tampilan terperinci, klik kiri dan tahan untuk menggeser ke atas dan ke bawah.
* Klik kiri di kolom Grafik untuk menambahkan grafik penggunaan kecil dengan nilai minimum dan maksimum. Klik grafik lagi untuk memperluasnya.
* Klik kanan pada grafik untuk menutupnya.
* Anda tidak dapat menyaring pandangan ini, tetapi Anda dapat mengklik kiri pada kategori (misalnya, memory ) untuk meliputnya.
Sementara mode counter bisa berguna, [Konsol Pengembang](/docs/id-id/studio/optimization/memory-usage) adalah cara yang direkomendasikan untuk [mengidentifikasi masalah memori](/docs/id-id/performance-optimization/identify#client-memory).Anda juga mungkin menemukan pandangan [sinar X](/docs/id-id/studio/microprofiler#use-the-web-ui) di UI web berguna untuk mengidentifikasi kapan alokasi memori bermasalah terjadi.
## [Mode tersembunyi](#mode-tersembunyi)
Mode tersembunyi menjaga menu MicroProfiler tetap terbuka, tetapi menyembunyikan grafik bar.Ini berguna untuk mengurangi kekacauan visual, [menyimpan data frame](/docs/id-id/studio/microprofiler#save-frame-data) , dan berhenti dan tidak berhenti saat Anda mengamati grafik garis.
| 38 |
https://create.roblox.com/docs/id-id/studio/microprofiler/task-scheduler
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [MicroProfiler](/docs/id-id/studio/microprofiler)
Bahasa Indonesia
Masukan
# Penjadwal tugas
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/microprofiler/task-scheduler).
Penjadwal tugas koordinasi tugas yang dilakukan setiap frame saat permainan berjalan, bahkan saat permainan dijeda .Tugas\-tugas ini termasuk mendeteksi input pemain, memanim animasi karakter, memperbarui simulasi fisika, dan melanjutkan skrip di negara [task.wait()](/docs/id-id/reference/engine/libraries/task#wait) status.
Meskipun mungkin ada banyak tugas yang berjalan, penjadwal tugas dapat berpotensi overload, terutama dalam situasi berikut:
* Menggunakan rig karakter khusus atau skema input.
* Animasi bagian sendiri (daripada menggunakan [Animator](/docs/id-id/reference/engine/classes/Animator) ).
* Bergantung sangat pada fisika yang tepat.
* Mereplikasi objek secara teratur.
## [Bingkai](#bingkai)
Sebuah frame adalah unit logika permainan di mana pekerjaan dilakukan .Setiap frame harus melakukan tugas secara efisien, yang mengarah pada lebih banyak frame per detik dan pengalaman pemutar yang lebih halus.
## [Jalankan Layanan](#jalankan-layanan)
Cara paling langsung untuk menambahkan tugas permainan frame\-by\-frame adalah melalui anggota berikut dari [RunService](/docs/id-id/reference/engine/classes/RunService) :
* [RunService:BindToRenderStep()](/docs/id-id/reference/engine/classes/RunService#BindToRenderStep)
* [RunService.PreAnimation](/docs/id-id/reference/engine/classes/RunService#PreAnimation)
* [RunService.PreRender](/docs/id-id/reference/engine/classes/RunService#PreRender)
* [RunService.PreSimulation](/docs/id-id/reference/engine/classes/RunService#PreSimulation)
* [RunService.PostSimulation](/docs/id-id/reference/engine/classes/RunService#PostSimulation)
* [RunService.Heartbeat](/docs/id-id/reference/engine/classes/RunService#Heartbeat)
## [Prioritas penjadwal](#prioritas-penjadwal)
Penjadwal tugas mengkategorikan dan menyelesaikan tugas dalam urutan berikut.Beberapa tugas mungkin tidak melakukan pekerjaan dalam frame, sementara yang lain dapat dijalankan beberapa kali.
## [Praktik terbaik](#praktik-terbaik)
Untuk membangun game berperforma dengan efisiensi dalam pikiran, perhatikan hal mengikuti:
* Janganhubungkan/ikat fungsi ke langkah render kecuali benar\-benar diperlukan.: Hanya tugas yang harus dilakukan setelah input tetapi sebelum rendering harus dilakukan dengan cara seperti itu, seperti gerakan kamera.Untuk kontrol ketat atas pesanan, gunakan [BindToRenderStep()](/docs/id-id/reference/engine/classes/RunService#BindToRenderStep) alih\-alih [PreRender](/docs/id-id/reference/engine/classes/RunService#PreRender).
* Kelola keadaan fisik dengan hati\-hati.: [PreSimulation](/docs/id-id/reference/engine/classes/RunService#PreSimulation) terjadi sebelum fisika, sementara [PostSimulation](/docs/id-id/reference/engine/classes/RunService#PostSimulation) terjadi setelah fisika.Oleh karena itu, logika gameplay yang memengaruhi negara fisika harus dilakukan di [PreSimulation](/docs/id-id/reference/engine/classes/RunService#PreSimulation) , seperti menetapkan [Velocity](/docs/id-id/reference/engine/classes/BasePart#Velocity) dari bagian.Sebaliknya, logika permainan yang bergantung pada atau bereaksi terhadap keadaan fisika harus ditangani di [PostSimulation](/docs/id-id/reference/engine/classes/RunService#PostSimulation) , seperti membaca [Position](/docs/id-id/reference/engine/classes/BasePart#Position) bagian untuk mendeteksi ketika mereka memasuki zona yang didefinisikan.
* Perubahan transformasi Motor6D harus dilakukan pada acara PreSimulation.: Jika Anda tidak, [Animators](/docs/id-id/reference/engine/classes/Animator) akan menghapus perubahan pada frame berikutnya.Bahkan tanpa [Animator](/docs/id-id/reference/engine/classes/Animator) , [PreSimulation](/docs/id-id/reference/engine/classes/RunService#PreSimulation) adalah acara Luau terakhir yang ditembak sebelum [Motor6D.Transform](/docs/id-id/reference/engine/classes/Motor6D#Transform) diterapkan ke posisi bagian.
| 39 |
https://create.roblox.com/docs/id-id/studio/microprofiler/tag-table
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [MicroProfiler](/docs/id-id/studio/microprofiler)
Bahasa Indonesia
Masukan
# Referensi tag
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/microprofiler/tag-table).
Berikut adalah daftar tag umum di MicroProfiler, dikelompokkan berdasarkan kategori.Memahami label ini dapat membantu Anda mengidentifikasi kode bermasalah dalam pengalaman Anda.Tabel berisi label tag, deskripsi, dan saran kinerja untuk meningkatkan kinerja dan mengoptimalkan pengalaman Anda.
## [Tidur](#tidur)
Ketika thread tidak aktif melakukan tugas, mereka memasuki keadaan tidur, dengan tag untuk menunjukkan berapa lama thread tidur.Pada saat tertentu, sangat umum bagi sebagian besar thread pekerja untuk berada dalam keadaan tidur.
## [AI/ navigasi](#ai-navigasi)
| Label | Deskripsi | Nasihat Perkinerja |
| --- | --- | --- |
| rasterizeTile | Ubin navigasi pembaruan diperlukan untuk permintaan penemuan jalur, biasanya diikuti oleh computePath yang memerlukan ubin tersebut up\-to\-date.Mengikuti NavigationJob/preprocess pada thread utama. | Kurangi jumlah invalidasi pencarian jalur, karena ini menyebabkan rute tersebut perlu dihitung ulang. Ini disebabkan oleh gerakan bagian yang tidak dapat dilalui. |
| computePath | Menghitung jalur, biasanya setelah rasterizeTile . | Kurangi jumlah dan batas dunia panggilan ComputePath .Coba gunakan kembali jalur untuk beberapa agen jika diharapkan untuk mulai/akhir dari lokasi yang hampir sama. |
| pramemproses/mendapatkanPrimitifOverlapping | Mengumpulkan geometri dunia untuk setiap ubin pencarian jalur dan menjadwalkan tugas rasterisasi untuk dieksekusi oleh thread pencarian jalur. | Kurangi jumlah bagian. |
## [Animasi](#animasi)
| Label | Deskripsi | Saran kinerja |
| --- | --- | --- |
| Simulasi/gameStepped | Pemrosesan objek spesifik permainan seperti [Humanoids](/docs/id-id/reference/engine/classes/Humanoid) , Animations dan panggilan balasan denyut jantung | |
| Simulasi/gameStepped/StepLegacy | [Humanoid](/docs/id-id/reference/engine/classes/Humanoid) perubahan status dan movement.Called stepHumanoid di server sekarang (versi paralel) | Nonaktifkan atau kurangi [Humanoid](/docs/id-id/reference/engine/classes/Humanoid).Status tangga paling penting untuk dinonaktifkan.Kurangi panggilan balasan untuk perubahan status seperti [Humanoid.Died](/docs/id-id/reference/engine/classes/Humanoid#Died) atau [Humanoid.Running](/docs/id-id/reference/engine/classes/Humanoid#Running) |
| Simulasi/gameStepped/stepAnimasi | [Animators](/docs/id-id/reference/engine/classes/Animator) akan melangkah maju dalam saat ini memainkan animasi. | Kurangi jumlah [Animators](/docs/id-id/reference/engine/classes/Animator) atau persambungan animasi untuk menurunkan beban kerja langkah ini.Kurangi jumlah panggilan balasan ke acara animasi seperti [AnimationTrack.KeyframeReached](/docs/id-id/reference/engine/classes/AnimationTrack#KeyframeReached) atau [AnimationTrack.Ended](/docs/id-id/reference/engine/classes/AnimationTrack#Ended) |
| Simulasi/gameStepped/RunService.Stepped | Menjalankan fungsi yang terhubung ke acara [RunService.Stepped](/docs/id-id/reference/engine/classes/RunService#Stepped) . | Kurangi jumlah atau beban kerja fungsi yang terhubung ke acara ini.Pertimbangkan untuk menunda atau mengganti perhitungan mahal.Pertimbangkan menyebarkan perhitungan di beberapa frame. |
## [Suara](#suara)
| Label | Deskripsi | Saran kinerja |
| --- | --- | --- |
| Suara | Memproses audio: lokasi, efek, volume, dll. | |
| Tag Pengembang\_Suara | Suara dalam Memori: suara pendek umumnya yang cukup kecil untuk masuk ke memori. Biasanya fx satu tembakan singkat, bukan musik berbentuk panjang. | Gunakan lebih sedikit suara pendek. |
| Tag Pengembang\_Suara Streaming | stream/StreamingSounds: ini adalah suara yang lebih besar yang diputar dari disk. Umumnya file musik bentuk panjang. | Gunakan lebih sedikit suara panjang. |
## [Jaringan](#jaringan)
| Label | Deskripsi | Saran kinerja |
| --- | --- | --- |
| Penerimaan Paket Jaringan | Menerima paket jaringan. Jika banyak objek atau peristiwa disalin, langkah ini membutuhkan lebih lama. | Replikasikan lebih sedikit objek atau peristiwa. |
| Replicator/ProsesPaket | Memproses konten paket jaringan, seperti gerakan, panggilan acara, dan perubahan properti. | Kurangi jumlah atau ukuran objek yang direplikasi, atau lakukan ini dalam langkah\-langkah incremental.Dapat meningkat jika ukuran peta meningkat, karena peta yang lebih besar cenderung memiliki lebih banyak aktivitas umum. |
| Menyediakan Bandwidth dan Jalankan Pengirim/Dispatch Fisik Pengirim dan TouchSenders | Mengirim data tentang aktivitas di pengalaman. | Kurangi jumlah objek bergerak dan/atau sentuhan. Lihat bagian berikut. |
| Menyediakan Bandwidth dan Jalankan Pengirim/Dispatch StreamJob | Mengirim wilayah spesifik yang sesuai ke klien spesifik di fitur "Streaming". | Kurangi radius streaming minimum dan target. |
| Menyediakan Bandwidth dan Menjalankan Pengirim/Dispatch Data Pengirim | Mengirim perubahan properti, peristiwa remote, perubahan status Humanoid, mulai/berhenti animasi. | Kurangi jumlah perubahan yang direplikasi ke model data |
| Klasifikasi Pengirim Replikator | Mengirim data Tanah kepada klien. | Kurangi jumlah atau ukuran perubahan Tanah. |
| ModelCompleteness Mega Pekerjaan | Hanya server: keseluruhan adalah konsep internal. Saat model dikirimkan sepenuhnya, peristiwa keseluruhan model dikirimkan. | Tambahkan atau hapus lebih sedikit instans. |
| Paket Desialisasi | Pemrosesan paket jaringan tingkat rendah. Persiapkan untuk Proses Paket Replikator. | Kirim lebih sedikit pembaruan. |
## [Rendering](#rendering)
| Label | Deskripsi | Catatan kinerja |
| --- | --- | --- |
| Siapkan | Informasi dikumpulkan dari thread utama dan memperbarui berbagai struktur data yang digunakan untuk rendering.Ini memblokir thread simulasi, sehingga harus sekecil mungkin. | Lihat Persiapkan label di bawah ini. |
| Siapkan/Pass3dAdorn | Menampilkan berbagai aksesori objek, seperti label teks di atas objek. Langkah ini mungkin termasuk raycasting untuk menentukan apakah objek tersebut terlihat. | Kurangi jumlah objek yang terlihat dilengkapi, seperti [BillboardGuis](/docs/id-id/reference/engine/classes/BillboardGui) , [Humanoid](/docs/id-id/reference/engine/classes/Humanoid) label nama/kesehatan, dll. |
| Siapkan/Pass2d | Siapkan rendering UI 2D (baik pemain maupun UI Roblox). | Kurangi jumlah atau kompleksitas elemen UI. |
| Siapkan/PerbaruiSiapkan/perbarui Bagian Tidak Valid | Memperbarui bagian yang memiliki beberapa properti diubah atau ditambahkan. | Kurangi jumlah perubahan properti di dunia. Jika skrip memperbarui kumpulan besar properti objek, hancurkan di antara frame. |
| Siapkan/PerbaruiSiapkan/perbarui Kluster Cepat Tidak Valid | Mempersiapkan geometri, biasanya "Kelompok Cepat" digunakan untuk menampilkan [Humanoids](/docs/id-id/reference/engine/classes/Humanoid) . Penanda sub menentukan jumlah bagian, vertex, dan ukuran vertex. | Kurangi penggunaan 'Humanoids' di bawah objek yang tidak [Humanoids](/docs/id-id/reference/engine/classes/Humanoid) .Ini tidak boleh digunakan untuk memperpendek panggilan tarik karena FastClusters mengkonsumsi lebih banyak memori. |
| Siapkan/PerbaruiSiapkan/perbaruiBagian Dinamis | Memperbarui posisi untuk [Humanoids](/docs/id-id/reference/engine/classes/Humanoid) , kendaraan, dan instans lain yang bergerak untuk rendering. | Kurangi jumlah atau kompleksitas gerakan [Humanoids](/docs/id-id/reference/engine/classes/Humanoid) atau kendaraan yang terlihat.Menggabungkan bagian dari bahan dan warna yang sama menjadi satu serikat atau MeshPart dapat membantu dengan ini. |
| Siapkan/PerbaruiSiapkan/perbaruiKelompok Terinstal | Mempersiapkan geometri statis yang menggunakan rendering instan (bagian dan bagian mesh). Label "Kelompok" dan "Instans" menunjukkan nomor yang diperbarui. | Gunakan kurang variasi mesh dan materi secara keseluruhan. Anda juga dapat membuat cluster dengan menggunakan objek yang memiliki penampilan serupa \- ukuran, warna, bahan. |
| Lakukan | Ketika perintah rendering aktual dibuat dan diterbitkan. | Lihat Label Perform di bawah ini. |
| Lakukan/isiGuiVertices | Render UI. Mengisi buffer dengan vertex UI untuk aksesori. Label "Gui count" menunjukkan jumlah elemen di daftar renderer. | Jika biaya tinggi, kurangi jumlah UI yang diperbarui dengan menonaktifkannya saat tidak digunakan dengan memastikan disembunyikan dengan benar. |
| Lakukan/Adegan/queryFrustumOrdered | Menerapkan pemilihan frustum sehingga objek yang tidak terlihat tidak ditampilkan. | Jika ada biaya tinggi yang berarti ada banyak elemen.Mungkin gunakan beberapa meshes yang lebih besar di mana satu meshes memiliki lebih banyak rincian dibandingkan dengan banyak bagian kecil. |
| Lakukan/Adegan/ computeLightingPerform | Perhitungan pencahayaan di dekat kamera. | Manipulasi jumlah sumber cahaya atau pindahkan kamera kurang untuk mengurangi waktu yang diperlukan untuk menghitung ulang pencahayaan. |
| Lakukan/Adegan/ computeLightingPerform/LightGridCPU | Memperbarui pencahayaan vokel, yang digunakan dalam mode [Voxel](/docs/id-id/reference/engine/enums/Technology) dan [ShadowMap](/docs/id-id/reference/engine/enums/Technology) dan pada tingkat kualitas di bawah 4 di mode [Future](/docs/id-id/reference/engine/enums/Technology). | Jika pembaruan kapasitas potongan memakan waktu terlalu lama, pertimbangkan untuk menggunakan geometri resolusi lebih rendah, mengurangi jumlah bagian, atau mengunci bagian.Jika sub\-penanda lain terlalu lama, pertimbangkan untuk mengurangi jumlah lampu dan menggunakan geometri lemparan non\-bayangan untuk objek yang bergerak dan membatalkan penempatan. |
| Lakukan/Adegan/ computeLightingPerform/ShadowMapSystem | Memperbarui peta bayangan. Tidak dilakukan pada tingkat kualitas di bawah 4 atau ketika [Lighting.Technology](/docs/id-id/reference/engine/classes/Lighting#Technology) diatur ke [Voxel](/docs/id-id/reference/engine/enums/Technology). | Jika pencahayaan diatur ke [Future](/docs/id-id/reference/engine/enums/Technology) , turunkan ke [ShadowMap](/docs/id-id/reference/engine/enums/Technology) atau kurangi jumlah lampu.Anda juga dapat menggunakan [Light.Shadows](/docs/id-id/reference/engine/classes/Light#Shadows) dan [BasePart.CastShadows](/docs/id-id/reference/engine/classes/BasePart#CastShadows) untuk menonaktifkan pencastan bayangan pada instans yang kurang penting.Lihat [Meningkatkan Kinerja](/docs/id-id/performance-optimization/improve#mitigation-4) . |
|
| Lakukan/Adegan/Bercahaya, Pengoreksi Warna, MSAA, SSAO, dan SSAOApply | Render pos\-pengolahan. | Kurangi jumlah efek post\-processing. Biasanya ini tidak signifikan. |
| Lakukan/Adegan/UI | Render UI. Di Id\_Screen, ada label dengan jumlah batch, bahan, dan segi yang digunakan. | Kurangi jumlah elemen UI yang terlihat. Menggunakan CanvasGroups mungkin membantu dengan pengorbanan penggunaan memori yang meningkat. |
| Lakukan/Adegan/UpdateView/updateParticles, updateParticleBoundings | Perbarui posisi dan batas partikel. | Kurangi jumlah [ParticleEmitters](/docs/id-id/reference/engine/classes/ParticleEmitter) , tingkat emisi, masa hidup, dll. Batasi pergerakan pemancar. |
| Id\_Opaque | Bagian dalam adegan dengan nilai transparansi 0\. | |
| Id\_Transparan | Bagian di adegan dengan nilai transparansi lain dari 0\. | Kurangi penggunaan transparansi parsial (nilai selain 0 dan 1\). |
| Id\_Decal | Stiker di adegan. | |
| Lakukan/Sajikan | Menunggu GPU menyelesaikan rendering frame sebelumnya; sebenarnya mengeluarkan perintah rendering ke GPU; berurusan dengan sumber daya grafis tingkat rendah. | Kurangi kompleksitas adegan secara umum. Jika langkah ini memakan waktu lama, Anda mungkin dibatasi oleh GPU. |
| Lakukan/Sajikan/Tunggu Sampai Selesai | Menunggu GPU untuk menyelesaikan rendering frame sebelumnya. | Jika ini umumnya terjadi banyak maka jumlah hal yang disajikan terlalu tinggi.FRM membantu menyeimbangkan ini, tetapi jika tetap tinggi, coba gunakan lebih sedikit rincian. |
## [Skrip](#skrip)
| Label | Deskripsi | Saran kinerja |
| --- | --- | --- |
| Render/PreRender/fireBindToRenderSteppedCallbacks | Menjalankan fungsi yang terikat untuk menampilkan langkah melalui [RunService:BindToRenderStep()](/docs/id-id/reference/engine/classes/RunService#BindToRenderStep) . | Pastikan fungsi dalam skrip menggunakan [RunService:BindToRenderStep()](/docs/id-id/reference/engine/classes/RunService#BindToRenderStep) melakukan sedikit pekerjaan mungkin. |
| Render/PreRender/RunService.RenderStepped | Menjalankan fungsi yang terhubung ke acara [RunService.RenderStepped](/docs/id-id/reference/engine/classes/RunService#RenderStepped) . | Mirip dengan BindToRenderStep , pastikan fungsi yang menggunakan peristiwa ini melakukan sedikit pekerjaan mungkin. |
| Menunggu Hybrid Script Job | Melanjutkan skrip yang menunggu menggunakan frame tunggu. | Langkah ini memiliki anggaran waktu eksekusi untuk menjalankan skrip tunggu, jadi jika Anda memiliki terlalu banyak skrip tunggu atau skrip dengan waktu eksekusi yang lama sebelum menyerah, langkah ini dapat mengambil banyak |
| LuaGC | Siklus pengumpulan limbah Luau. Label memberikan perkiraan memori tentang alokasi total dan berapa banyak yang didelegasikan. | Tabel lua kolam dan objek koleksi lainnya atau cobalah untuk mengurangi pembuatan tabel sementara atau string |
| Detak Jantung/RunService.Heartbeat | Menjalankan fungsi yang terhubung ke Class.RunService.Heartbeat\`\`event.Talk ke kontak simulasi dan skrip. Deskripsi saat ini cukup umum untuk tidak salah | Kurangi jumlah atau beban kerja fungsi yang terhubung ke RunService.Heartbeat. |
## [Simulasi](#simulasi)
| Label | Deskripsi | Saran kinerja |
| --- | --- | --- |
| Kepemilikan Fisika Terdistribusi | Menentukan apakah server atau klien memiliki otoritas atas instans tertentu seperti bagian. | Kepemilikan Fisika Terdistribusi. |
| Simulasi/assemble | Memperbarui pohon objek terhubung (assemble) yang digunakan oleh mesin fisika. | Kurangi jumlah persambungan yang dibuat atau dihancurkan. |
| Simulasi/fisikaSteppedTotal/fisikaStepped | Mengejal simulasi fisika. | Kurangi jumlah dan kompleksitas tubuh fisik yang disimulasikan. |
| Simulasi/fisikaSteppedTotal/fisikaStepped/SpatialFilter/filterLangkah | Memperbarui pulau simulasi, mengatur bagian sesuai dengan kepemilikan jaringan, simulasi lokal.Pulau adalah kelompok bagian yang tidak berinteraksi yang dapat disimulasikan secara independen. | Hindari sering menetapkan kepemilikan jaringan. Jaga agar kelompok bagian tetap cukup jauh dari satu sama lain sehingga mereka dapat disimulasikan secara terpisah. |
| Simulasi/fisikaLangkah Total/fisika Langkah/duniaLangkah Kontak | Memperbarui kontak antara objek. | Kurangi jumlah tubuh yang bertabrakan sekaligus, atau gunakan kotak tabrakan yang lebih sederhana. Kubus lebih baik daripada meshes yang kompleks. |
| Simulasi/fisikaSteppedTotal/physicsStepped/worldStep/stepWorld ATAU stepWorldThrottled | Memecahkan persamaan fisika yang berhubungan dengan konektor, buoyancy, dan [Humanoids](/docs/id-id/reference/engine/classes/Humanoid) .Ketika mesin overloaded dan tidak dapat menyimulasikan semuanya secara real time, beberapa langkah mungkin dibatasi (stepWorldThrottled) dan hanya "assemble real time" seperti [Humanoids](/docs/id-id/reference/engine/classes/Humanoid) yang disimulasikan. | Tergantung pada di mana waktu akan berjalan berdasarkan tiga fase berikut: stepContacts: tes geometri deteksi tabrakan fase sempit.Langkah penyelesaian: gabungkan waktu dan memecahkan konflik dan keterbatasan lainnya updateBroadphase: temukan posisi assemblies dalam sistem deteksi kolisi dan temukan kemungkinan pas fase sempit yang bertabrakan. |
| Memberi pemberitahuanMovingAssemblies | Membantu melacak berapa lama primitif telah tidur. | |
| Simulasi/fisikaSteppedTotal/fisikaStepped/interpolateJaringanAssemble | Menggabungkan assemblasi yang tidak dikendalikan oleh peer jaringan ini. | Tetapkan pemilik jaringan bagian ke peer ini untuk mengurangi ini; meskipun ini biasanya akan menyebabkan lebih banyak pekerjaan fisika dilakukan di tempat lain. |
| Simulasi/handleFallenParts | Menghapus bagian yang telah jatuh di bawah Workspace/FallenPartsDestroyHeight. | Turunkan ketinggian hancur atau kurangi jumlah bagian yang jatuh ke ketinggian hancur. |
| Detak jantung/detak jantungInternal/workspaceOnHeartbeat/updateVisuallySleeping | Bagian kedua dari NotifyMovingAssemblies. | |
| Detak Jantung/RunService.Heartbeat | Menjalankan fungsi yang terhubung ke Class.RunService.Heartbeat\`\`event.Talk ke kontak simulasi dan skrip. Deskripsi saat ini cukup umum untuk tidak salah | Kurangi jumlah atau beban kerja fungsi yang terhubung ke [RunService.Heartbeat](/docs/id-id/reference/engine/classes/RunService#Heartbeat). |
| worldStep/StepKontak | Membantu langkah simulasi fisika mengontak banyak kontak sekaligus. | Kurangi jumlah objek yang bertabrakan. |
| Menyelesaikan batch | Membantu simulasi fisika menyelesaikan batch gerakan objek. | |
| Interpolasi Mekanisme | Membantu dengan InterpolateNetworkAssemblies. | |
## [UI](#ui)
| Label | Deskripsi | Saran kinerja |
| --- | --- | --- |
| Render/PreRender/UpdateInput | Memperbarui dan menyalakan semua peristiwa input pengguna terkait jika pengguna telah melakukan input sejak frame terakhir. | Ini adalah ketika peristiwa yang terkait dengan input pengguna akan terbakar.Penting untuk mencoba dan tidak melakukan terlalu banyak pekerjaan langsung saat Anda mendapatkan input.Pertimbangkan melakukan jumlah minimal pemrosesan untuk input, dan perhitungan yang lebih besar harus ditunda ke thread lain yang terjadi nanti. |
| Render/PreRender/TweenService | Memperbarui objek yang diselingkuh menggunakan [TweenService](/docs/id-id/reference/engine/classes/TweenService) dan memanggil panggilan panggilan penyelesaian, seperti yang digunakan disediakan ke TweenSize atau TweenPosition . | Kurangi jumlah objek yang ditransisi menggunakan TweenService dan pastikan panggilan balasan melakukan sedikit pekerjaan mungkin. |
| Render/PreRender/UpdateUILayouts | Memperbarui posisi dan ukuran elemen UI. | Kurangi jumlah elemen UI yang diubah ukurannya atau dipindahkan secara dinamis, seperti yang dikelola oleh [UILayout](/docs/id-id/reference/engine/classes/UILayout). |
| Detak Jantung/TweenService | Di server, objek diperbarui dengan TweenService. Di klien, ini dilakukan dalam langkah PreRender sebagai gantinya. | Kurangi jumlah objek yang ditweened oleh [TweenService](/docs/id-id/reference/engine/classes/TweenService) . |
| 40 |
https://create.roblox.com/docs/id-id/studio/microprofiler/use-microprofiler
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [MicroProfiler](/docs/id-id/studio/microprofiler)
Bahasa Indonesia
Masukan
# Panduan MicroProfiler
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/microprofiler/use-microprofiler).
Panduan ini menunjukkan cara menggunakan MicroProfiler untuk menemukan aspek problematik dari pengalaman dan mengidentifikasi penyebab akar.Unduh pengalaman, Buka dari File di Studio, dan ikuti.
[Unduh Pengalaman](https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/RaycastSpam.rbxl)
## [Identifikasi masalah](#identifikasi-masalah)
1. Setelah Anda membuka pengalaman di Studio, mulailah menguji dengan F5 atau tombol Mainkan .
2. Tingkat frame terasa layak, tetapi tidak sehalus seharusnya untuk pengalaman dengan ukuran dan cakupan ini.Navigasikan ke tab Pandangan dan klik Ringkasan di bawah [Statistik](/docs/id-id/studio/view-tab#diagnostic-stats).
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-tut-framerate.png' alt='Debug stats summary showing 45 FPS.' title='' width='500px' height='' />Perhatikan bahwa tingkat frame berada di bawah 60 frame per detik (FPS).
3. Buka MicroProfiler dengan menekan CtrlAltF6 ( ⌘⌥F6 ).
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-tut-bar-graph.png' alt='The MicroProfiler after opening it.' title='' width='500px' height='' />Perhatikan bahwa waktu bingkai adalah konsisten —bilahnya kira\-kira memiliki ketinggian yang sama—jadi apa pun yang menyebabkan tingkat bingkai rendah berjalan setiap frame sebagai lawan dari berjalan sesekali dan menyebabkan lonjakan waktu bingkai.
4. Jeda MicroProfiler dengan menekan CtrlP ( ⌘P ).Pause dengan pintasan keyboard membuka [mode terperinci](/docs/id-id/studio/microprofiler/modes#detailed-mode).
5. Klik dan seret untuk memutar grafik.Perhatikan bagaimana tugas tertentu di thread pekerja tampaknya menggunakan banyak waktu pemrosesan dibandingkan dengan thread utama.Pasang di atas [RunService.Stepped](/docs/id-id/reference/engine/classes/RunService#Stepped) dan perhatikan berapa lama waktu yang dibutuhkan untuk menampilkan.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-tut-stepped.png' alt='Detailed mode with long labels for processes.' title='' width='600px' height='' />
6. Bar tumpukan di timeline menunjukkan hierarki kode, jadi tetap berada di atas dan di bawah lapisan untuk mencoba dan mengidentifikasi masalah.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-tut-localscript.png' alt='On-hover details for various processes, with LocalScript highlighted.' title='' width='600px' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-tut-raycast-label.png' alt='On-hover details for various processes, with Raycast highlighted.' title='' width='600px' height='' />Perhatikan label LocalScript , yang menunjukkan nama skrip, dan label Raycast , yang menunjukkan bahwa masalahnya mungkin terkait dengan raycasting.
## [Buat label solusi masalah](#buat-label-solusi-masalah)
Sekarang MicroProfiler telah memberikan titik awal, Anda dapat memecahkan masalah kode yang bermasalah.
1. Hentikan tes bermain dan filter jendela Explorer untuk localscript menemukan file.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-tut-explorer-filter.png' alt='A view of filtering in the Explorer window.' title='' width='400px' height='' />Pencarian untuk raycast menunjukkan bahwa bagian kode ini mungkin adalah penyebab buruk kinerja pelaksanaan:
```
---
```
local RAYS_PER_SECOND = 1500
local function onStepped()
for _ = 1, RAYS_PER_SECOND do
local startPosition = getRandomPosition()
local endPosition = getRandomPosition()
local direction = endPosition - startPosition
Workspace:Raycast(
startPosition,
endPosition
)
end
end
RunService.Stepped:Connect(onStepped)
```
```
Secara khusus, Anda dapat melihat bahwa kode memancarkan 1\.500 sinar per detik ke arah acak.
2. Untuk memverifikasi bahwa bagian kode ini menyebabkan penundaan rendering, bungkus konten fungsi dengan [debug.profilebegin()](/docs/id-id/reference/engine/libraries/debug#profilebegin) dan [debug.profileend()](/docs/id-id/reference/engine/libraries/debug#profileend) :
```
---
```
local function onStepped()
debug.profilebegin("Raycast Spam")
for _ = 1, RAYS_PER_SECOND do
local startPosition = getRandomPosition()
local endPosition = getRandomPosition()
local direction = endPosition - startPosition
Workspace:Raycast(
startPosition,
endPosition
)
end
debug.profileend()
end
```
```
## [Konfirmasi dan perbaiki masalah](#konfirmasi-dan-perbaiki-masalah)
1. Mulai menguji pengalaman, dan buka MicroProfiler lagi.
2. Perhatikan bagaimana MicroProfiler sekarang menampilkan label khusus, menunjukkan bahwa fungsi ini memang penyebab akar.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-tut-spam.png' alt='MicroProfiler detailed view with 'Raycast Spam' visible.' title='' width='500px' height='' />
3. Hentikan tes permainan.
4. Hapus atau komentari fungsi onStepped() dan koneksi RunService.Stepped:Connect(onStepped).
5. Mulai uji pengalaman lagi, dan periksa ringkasan statistik debug lagi.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/microprofiler/micro-tut-framerate2.png' alt='Debug stats summary showing 60 FPS.' title='' width='500px' height='' />Perhatikan peningkatan besar pada tingkat bingkai dan penurunan yang sesuai pada waktu bingkai di grafik MicroProfiler.
| 41 |
https://create.roblox.com/docs/id-id/studio/developer-console
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [Konsol Developer](/docs/id-id/studio/developer-console)
Bahasa Indonesia
Masukan
# Konsol Pengembang
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/developer-console).
Konsol Pengembang adalah alat untuk mendiagnosis pengalaman Anda saat menguji di Studio atau menjalankannya di produksi.Ini menunjukkan pesan log dan kesalahan yang mirip dengan jendela [Output](/docs/id-id/studio/output) dan informasi terperinci tentang [Memori](#memory) , [Jaringan](#network) , dan banyak lagi.
Anda dapat membuka konsol selama sesi pengujian atau pengalaman langsung menggunakan salah satu dari cara berikut:
* Tekan F9.
* Ketik /console ke dalam obrolan.
* Gunakan menu dalam pengalaman:
1. Buka menu dalam pengalaman Roblox .
<img src='https://prod.docsiteassets.roblox.com/assets/ui/misc/Roblox-Menu-Button.png' alt='' title='' width='680' height='' />
2. Pilih tab Pengaturan .
3. Gulir ke bawah ke Konsol Pengembang dan klik Buka .
## [Bagian konsol](#bagian-konsol)
Tombol pintas di bagian atas konsol menunjukkan jumlah kesalahan kritis dan peringatan, penggunaan memori klien, dan waktu ping rata\-rata; klik salah satu dari ini untuk melompat ke bagian yang sesuai di konsol.Di bawah bilah pintasan adalah serangkaian alat seperti yang dijelaskan di bawah ini.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Console-Summary-Bar.png' alt='' title='' width='640' height='' />
### [Catatan](#catatan)
Alat Log menunjukkan pesan diagnostik dari skrip.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Log-Sections.png' alt='' title='' width='780' height='' />Client/server beralih
Filter keluaran
Bar perintah
Menggunakan sakelar klien\-server, Anda dapat beralih antara Klien dan Server pandangan:
* Tampilan Klien menunjukkan output dari sisi klien [LocalScripts](/docs/id-id/reference/engine/classes/LocalScript) dan/atau [Scripts](/docs/id-id/reference/engine/classes/Script) dengan [RunContext](/docs/id-id/reference/engine/classes/Script#RunContext) diatur ke [Enum.RunContext.Client](/docs/id-id/reference/engine/enums/RunContext#Client) .Siapa pun yang menjalankan pengalaman dapat melihat pesan output lokal.
* Tampilan Server menunjukkan output dari sisi server ( ditetapkan ke atau ).Hanya pemilik pengalaman atau anggota kelompok grup dengan izin编辑 dapat melihat pesan output server.
### [Ingatan](#ingatan)
Konsol Pengembang memberikan dua alat untuk memantau penggunaan memori, termasuk:
* Memori — Lihat konsumsi memori real time oleh kategori penggunaan, termasuk penggunaan memori oleh komponen kustom Anda dan proses internal mesin.
* Tumpukan Luau — Buat tangkapan layar pada memori heap, yang merujuk pada alokasi memori ke skrip Anda.Alat ini menyediakan berbagai pandangan alokasi memori untuk membantu Anda mengidentifikasi alokasi memori saat ini dan masalah dari perspektif yang berbeda, seperti jenis objek dan Kelasmesin.Ini juga memungkinkan Anda untuk membuat banyak snapshot untuk membandingkan perbedaan penggunaan memori seiring waktu.
Untuk informasi lebih lanjut, lihat [Penggunaan Memori](/docs/id-id/studio/optimization/memory-usage)
### [Jaringan](#jaringan)
Alat Jaringan menunjukkan jumlah panggilan web yang telah dilakukan pengalaman.Ini termasuk panggilan eksplisit yang dilakukan melalui [HttpService](/docs/id-id/reference/engine/classes/HttpService) dan permintaan web yang dibuat oleh layanan Roblox seperti [DataStoreService](/docs/id-id/reference/engine/classes/DataStoreService) .Alat Jaringan memiliki dua bagian:
* Bagian Ringkasan mencantumkan ringkasan dari semua panggilan web berdasarkan ketik.Setiap jenis memiliki rincian tentang jumlah permintaan, jumlah permintaan gagal, dan jumlah waktu yang diambil permintaan.
* Bagian Detail daftar setiap panggilan web individu.Setiap baris menunjukkan metode HTTP, seperti GET atau POST , bersama dengan kode status, waktu untuk dieksekusi, ketikpermintaan, dan URL permintaan.Klik pada panggilan web untuk melihat rincian responsnya, misalnya:
*"Version": "1\.1": "Konten": "Header": \[],"Status": "OK", "Alasan Frasa": "OK", "Header": \[],"Ekor Kepala": \[],"Pesan Permintaan": null,"Status Keberhasilan": true*
### [Pencari Profil Skrip](#pencari-profil-skrip)
Alat Profil Skrip memungkinkan Anda untuk merekam sesi profilasi semua skrip yang berjalan dan melihat biaya waktu CPU mereka dengan pengaturan perekaman dan tampilan khusus.Ini berguna untuk mengidentifikasi skrip yang mengambil sumber daya CPU paling banyak dan memperlambat pelaksanaan.Untuk informasi lebih lanjut, lihat [Profil Skrip](/docs/id-id/studio/optimization/scriptprofiler).
| 42 |
https://create.roblox.com/docs/id-id/studio/optimization/scriptprofiler
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [Konsol Developer](/docs/id-id/studio/developer-console)
Bahasa Indonesia
Masukan
# Pencari Profil Skrip
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/optimization/scriptprofiler).
Profil Skrip adalah alat dalam [Konsol Pengembang](/docs/id-id/studio/developer-console) yang memungkinkan Anda untuk merekam sesi profilasi semua skrip yang dijalankan dan melihat biaya waktu CPU mereka dengan pengaturan perekaman dan tampilan khusus.Ini dapat merekam semua jenis panggilan fungsi, termasuk panggilan fungsi Luau, panggilan metode, dan akses properti.Alat ini berguna untuk mengidentifikasi skrip yang mengambil sumber daya CPU paling banyak dan memperlambat pelaksanaan.
Profil skrip hanya mencatat panggilan fungsi yang mengkonsumsi sumber daya CPU, jadi tidak mencatat thread yang tidur atau menunggu hasil.
## [Catat sesi profilasi rekaman](#catat-sesi-profilasi-rekaman)
Sebelum merekam, Anda perlu memilih lingkungan perekaman dari:
* Klien (Standar) — Merekam skrip sisi klien, termasuk [LocalScripts](/docs/id-id/reference/engine/classes/LocalScript) dan [Scripts](/docs/id-id/reference/engine/classes/Script) dengan [RunContext](/docs/id-id/reference/engine/classes/BaseScript#RunContext) diatur ke [Client](/docs/id-id/reference/engine/enums/RunContext#Client) .
* Server — Merekam skrip sisi server, termasuk [Scripts](/docs/id-id/reference/engine/classes/Script) dengan [RunContext](/docs/id-id/reference/engine/classes/BaseScript#RunContext) diatur ke [Server](/docs/id-id/reference/engine/enums/RunContext#Server) atau [Legacy](/docs/id-id/reference/engine/enums/RunContext#Legacy) .Profil Skrip menghapus semua data sisi server yang dikumpulkan di akhir setiap sesi.
Anda juga dapat mengatur opsi rekaman berikut:
| Perilaku | Pilihan | Standar | Deskripsi |
| --- | --- | --- | --- |
| Frekuensi | 1000 kali per detik (1 KHz)10\.000 kali per detik (10 KHz) | 1 KHz | Frekuensi 10 KHz memiliki ketepatan lebih tinggi, karena Script Profiler mungkin tidak mendeteksi panggilan API yang dieksekusi lebih sering dari frekuensi yang Anda pilih, tetapi juga memiliki biaya kinerja yang lebih tinggi. |
| Durasi Sesi | Manual 1 menit5 menit10 menit | Manual | Opsi manual memerlukan Anda untuk berhenti merekam secara manual. |
| Perilaku Polling Langsung | PadaMati | Ditutup | Perilaku ini memperoleh dan menyegarkan data profil setiap detik selama sesi profilasi. |
Untuk merekam sesi profil baru:
1. Buka [Konsol Pengembang](/docs/id-id/studio/developer-console#opening-the-developer-console).
2. Perluas dropdown alat untuk memilih ScriptProfiler .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/ScriptProfiler-Open.png' alt='Dropdown menu of all Developer Console tools with the ScriptProfiler option highlighted for selection.' title='' width='200' height='' />
3. Perluas dropdown klien\-server untuk memilih Klien atau Server .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Client-Server-Dropdown.png' alt='Dropdown menu with Client and Server options for selection.' title='' width='600' height='' />
4. (Opsi) Periksa kotak centang Langsung untuk mengaktifkan perilaku polling langsung.
5. (Opsi) Pilih Frekuensi dan Waktu untuk memilih frekuensi perekaman dan durasi sesi jika Anda tidak ingin menggunakan nilai default.
6. Klik Mulai untuk memulai sesi profilasi.Jika Anda mengatur durasi, Profil Skrip menampilkan penghitung mundur dengan waktu yang tersisa dalam sesi.
7. Klik Berhenti atau tunggu sampai perekaman selesai untuk menampilkan data profil.
## [Baca data profilasi](#baca-data-profilasi)
Setelah sesi berhenti, Profil Skrip menghasilkan tabel yang menunjukkan berapa banyak waktu yang dibutuhkan setiap panggilan fungsi di waktu CPU.Fungsi urutan meja mengurutkan panggilan fungsi dari yang paling banyak dibelanjakan ke yang paling sedikit dibelanjakan, dan memungkinkan Anda untuk mencari fungsi tertentu dengan nama mereka.Ini memberikan dua pandangan berikut:
* Callgraph (Standar): Mengkategorikan dan menampilkan panggilan fungsi ke dalam struktur pohon berdasarkan tugas frame.Tampilan ini menampilkan setiap kategori tugas sebagai node di bawah akar yang sama dan memungkinkan Anda untuk memperluasnya untuk melihat fungsi.Anda juga dapat mengarahkan kursor ke node mana pun di pohon untuk melihat informasi file dan baris.Sebagai contoh, Langkah/Input Kamera/\<anonymous\> mungkin mengungkapkan Players.\[LocalPlayer].PlayerScripts.PlayerModule.CameraModule.CameraInput:125 .<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Callgraph.jpeg' alt='Example callgraph view of a profiling session.' title='' width='800' height='' />
* Fungsi : Daftar semua fungsi tanpa mengkategorikan mereka berdasarkan tugas.<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Functions.jpeg' alt='Example functions view of a profiling session.' title='' width='800' height='' />
Anda juga dapat memilih dari opsi tampilan berikut untuk menyesuaikan kebutuhan debugging Anda:
| Nama | Pilihan | Standar | Deskripsi |
| --- | --- | --- | --- |
| Satu | Milidetik (ms)Persentase (%) | ms | Menampilkan waktu yang dihabiskan untuk setiap panggilan API dalam milidetik atau persentase dari sesi perekaman total. |
| Rata\-rata | Mati1\- detik1\-menit5\-menit10\-menit | Ditutup | Menghitung rata\-rata waktu yang dihabiskan untuk setiap panggilan API oleh nilai yang dipilih.Jika Anda memilih opsi yang lebih lama dari durasi sesi, profiler skrip melampaui durasi sesi untuk menghitung rata\-rata.Sebagai contoh, Anda dapat memilih opsi 5 menit untuk sesi 1 menit untuk melihat nilai rata\-rata yang diharapkan jika Anda menjalankan kode selama 5 menit. |
## [Ekspor data profilasi](#ekspor-data-profilasi)
Profiler Skrip memungkinkan Anda untuk mengekspor data profil yang direkam sebagai file JSON. Untuk mengekspor data yang direkam setelah sesi profil:
1. Di jendela Profil Skrip, klik Ekspor .
2. Di jendela ekspor, pilih sesi profil yang ingin Anda ekspor. Ganti nama file default jika Anda ingin menetapkan nama khusus.
3. Klik Ekspor untuk menyimpan file JSON.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Export-Window.jpeg' alt='Example export window.' title='' width='600' height='' />
File JSON yang diekspor termasuk bidang berikut:
* Versi : Nomor versi.
* Waktu Mulai Sesi : Sebuah timestamp dalam milidetik yang mencatat waktu mulai sesi.
* Waktu Akhir Sesi : Sebuah timestamp dalam milidetik yang mencatat waktu akhir sesi.
* Kategori : Sebuah array kategori tugas frame yang dicatat dalam sesi profil. Setiap entri termasuk:
+ Nama : Nama setiap kategori tugas frame.
+ NodeId : Pengenal unik dari kategori tugas (node).Ini adalah indeks berbasis 1 ke array Nodes .Sebagai contoh, Anda dapat melihat node dengan NodeId dari 123 dengan mengambil elemen ke\-123 di Nodes .
* Nodes : Sebuah array node yang direkam dalam sesi profil. Setiap entri termasuk:
+ Durasi Total : Jumlah waktu yang dikenakan node dalam waktu CPU dalam milidetik.
+ FunctionIds : Sebuah array identifikator unik fungsi.
+ NodeIds : Sebuah array dari ID Node.
* Fungsi : Sebuah array fungsi yang direkam dalam sesi profil.
+ Durasi Total : Jumlah waktu yang dibutuhkan fungsi dalam waktu CPU dalam milidetik.
+ Nama : Nama fungsi, jika tersedia.
+ Sumber : Sumber fungsi, jika tersedia.
+ Garis : Nomor baris fungsi, jika tersedia.
+ Flags : Bidang sedikit yang menunjukkan lingkungan eksekusi fungsi tertentu. Saat ini dapat memiliki nilai berikut:
- 0 : Bit ke\-0 mewakili IsNative untuk eksekusi di bawah Native CodeGen.
- 1 : Bit ke\-1 mewakili IsPlugin untuk dieksekusi sebagai bagian dari plugin.
```
Contoh Data Profiling Ekspor Contoh
---
```
{
"Version":2,
"SessionStartTime":1704850750514,
"SessionEndTime":1704850751198,
"Categories":
[
{"Name":"Parallel Luau","NodeId":4},
{"Name":"Heartbeat","NodeId":1}
],
"Nodes":
[
{"TotalDuration":2530,"FunctionIds":[1],"NodeIds":[2]},
{"TotalDuration":2530,"FunctionIds":[2,5],"NodeIds":[3,7]},
{"TotalDuration":1267},
{"TotalDuration":7746,"FunctionIds":[3],"NodeIds":[5]},
{"TotalDuration":7746,"FunctionIds":[4],"NodeIds":[6]},
{"TotalDuration":7746},
{"TotalDuration":1263,"FunctionIds":[6],"NodeIds":[8]},
{"TotalDuration":1263,"FunctionIds":[7],"NodeIds":[9]},
{"TotalDuration":1263,"FunctionIds":[8],"NodeIds":[10]},
{"TotalDuration":1263}
],
"Functions":
[
{"Name":"main","TotalDuration":2530},
{"Source":"builtin_ManageCollaborators.rbxm.ManageCollaborators.Packages._Index.roblox_rodux-3.0.0.rodux.Store","Line":81,"TotalDuration":1267},
{"Name":"Script","TotalDuration":7746},
{"Source":"Workspace.Actor.Script","Line":1,"TotalDuration":7746},
{"Source":"builtin_DeveloperInspector.rbxm.DeveloperInspector.Packages._Index.DeveloperFramework.DeveloperFramework.UI.Components.Grid","Line":221,"TotalDuration":1263},
{"Source":"builtin_DeveloperInspector.rbxm.DeveloperInspector.Packages._Index.DeveloperFramework.DeveloperFramework.UI.Components.Grid","Name":"_update","Line":236,"TotalDuration":1263},
{"Source":"builtin_DeveloperInspector.rbxm.DeveloperInspector.Packages._Index.DeveloperFramework.DeveloperFramework.UI.Components.Grid","Name":"_getRange","Line":277,"TotalDuration":1263},
{"Source":"[C]","Name":"ScrollingFrame.CanvasPosition","TotalDuration":1263}
]
}
```
```
| 43 |
https://create.roblox.com/docs/id-id/studio/optimization/memory-usage
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
4. /
5. [Konsol Developer](/docs/id-id/studio/developer-console)
Bahasa Indonesia
Masukan
# Penggunaan memori
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/optimization/memory-usage).
Setiap komponen bangunan dan skrip yang Anda tambahkan ke pengalaman Anda mengkonsumsi memori.Ketika penggunaan memori mencapai batas mesin, perangkat atau server pengguna mungkin mogok, sehingga Anda perlu secara aktif memantau penggunaan memori dan mengambil tindakan untuk optimisasi. Konsol Pengembang menyediakan dua alat untuk memantau penggunaan memori, termasuk:
* [Memori](#memory) — Lihat konsumsi memori real time oleh kategori penggunaan, termasuk penggunaan memori oleh komponen kustom Anda dan proses internal mesin.
* [Tumpukan Luau](#luau-heap) — Buat tangkapan layar pada memori heap, yang merujuk pada alokasi memori ke skrip Anda.Alat ini menyediakan berbagai pandangan alokasi memori untuk membantu Anda mengidentifikasi alokasi memori saat ini dan masalah dari perspektif yang berbeda, seperti jenis objek dan Kelasmesin.Ini juga memungkinkan Anda untuk membuat banyak snapshot untuk membandingkan perbedaan penggunaan memori seiring waktu.
Anda dapat membuka konsol selama sesi pengujian atau pengalaman langsung menggunakan salah satu dari cara berikut:
* Tekan F9.
* Ketik /console ke dalam obrolan.
* Gunakan menu dalam pengalaman:
1. Buka menu dalam pengalaman Roblox .
<img src='https://prod.docsiteassets.roblox.com/assets/ui/misc/Roblox-Menu-Button.png' alt='' title='' width='680' height='' />
2. Pilih tab Pengaturan .
3. Gulir ke bawah ke Konsol Pengembang dan klik Buka .
## [Ingatan](#ingatan)
Alat Memori mengkategorikan dan menampilkan penggunaan memori real time.Ini menampilkan penggunaan memori dalam MB dari setiap kategori dan menghasilkan bagan tentang perubahan penggunaan seiring waktu.
Untuk melihat alokasi memori:
1. Buka Konsol Pengembang .
2. Perluas dropdown alat untuk memilih Memori .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Memory-Open.png' alt='Dropdown menu of all Developer Console tools with the Memory option highlighted for selection.' title='' width='200' height='' />
3. Perluas dropdown klien\-server untuk memilih Klien atau Server .
4. Telusuri kategori dan item penggunaan memori.Untuk kategori atau item yang ingin Anda lihat pola penggunaan overtime, perluas kategori untuk menampilkan grafik.
* Memori Inti — Penggunaan memori oleh proses pembangunan inti mesin, termasuk jaringan, avatar, dan elemen GUI (Antarmuka Pengguna Grafis) yang tidak Anda miliki kontrol langsung.
* Tempat Memori — Penggunaan memori berdasarkan bagaimana Anda membangun pengalaman Anda, termasuk model, medan, bagian, skrip, dan semua elemen khusus lainnya yang Anda tambahkan ke pengalaman Anda.
Referensi Memori Tempat
| Kategorisasi | Deskripsi |
| --- | --- |
| HttpCache | Aset (gambar, meshes, dll.) yang diunduh dari server Roblox dan sekarang disimpan dalam cache di memori |
| Instansi | [Instances](/docs/id-id/reference/engine/classes/Instance) di tempat. |
| Sinyal | Sinyal yang menembak di antara instans (peristiwa menembak pada satu kejadianuntuk memicu peristiwa di instans lain). |
| LuaHeap | Memori heap untuk kedua skrip utama (skrip yang dikirim dengan klien Roblox) dan skrip khusus. |
| Skrip | Skrip Luau. |
| Kolisi Fisika | Data kolisi untuk simulasi fisika. |
| Bagian Fisika | Geometri fisika dan kinetika. |
| Model Solid Grafis | Data grafis untuk menampilkan model solid. |
| Bagian Grafis Meshes | Grafik untuk [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) objek. |
| Partikel Grafis | Grafik untuk sistem partikel. |
| Bagian Grafis | Grafik untuk bagian. |
| Hash Ruang Grafis | Rendering umum. |
| Tanah Grafis | Grafik untuk medan. |
| Tekstur Grafis | Memori tekstur. |
| Karakter Teks Grafis | Memori tekstur untuk karakter. |
| Suara | Suara dalam memori. |
| Suara Streaming | Suara streaming. |
| TerrainVoxels | Voksels medan. |
| Fisika Tanah | Fisika medan. |
| Gui | Memori yang digunakan oleh elemen GUI umum. |
| Animasi | Memori yang digunakan untuk data animasi, seperti posisi dan [KeyframeSequence](/docs/id-id/reference/engine/classes/KeyframeSequence) data yang disimpan untuk animasi avatar. |
| Navigasi | Memori yang digunakan oleh struktur pendukung untuk [PathfindingService](/docs/id-id/reference/engine/classes/PathfindingService) . |
* Memori Tak Dilacak — Alokasi memori yang sistem tidak dapat dengan mudah atribusikan ke sumber tertentu.
* Memori Skrip Tempat — Penggunaan memori skrip Anda dengan wawasan tentang bagaimana skrip individu dan tag memori khusus berkontribusi pada penggunaan memori keseluruhan.
* Memori CoreScriptMemory — Penggunaan memori oleh skrip mesin internal yang tidak Anda miliki kontrol langsung.Di antara kategori ini, PlaceMemory dan PlaceScriptMemory adalah yang paling penting untuk optimisasi kinerja, karena mereka membantu Anda memahami bagaimana pilihan bangunan dan skrip Anda memengaruhi konsumsi memori dan area potensial untuk optimisasi.Untuk lebih banyak wawasan tentang Luau heap , Anda dapat menggunakan alat [Luau heap](#luau-heap) untuk membuat snapshot dan menganalisis alokasi memori dengan metrik yang berbeda.
Untuk informasi lebih lanjut tentang masalah penggunaan memori umum dan praktik terbaik, lihat [Optimisasi Kinerja](/docs/id-id/performance-optimization/improve#memory-usage).
## [Tumpukan Luau](#tumpukan-luau)
Alat Luau heap memungkinkan Anda untuk membuat snapshot pada alokasi heap memori saat ini, yang merujuk pada alokasi memori untuk skrip Luau untuk menyimpan variabel, tabel, fungsi, dan struktur data runtime lainnya.Alat ini menyediakan berbagai pandangan alokasi memori untuk membantu Anda mengidentifikasi alokasi memori dan masalah dari perspektif yang berbeda, seperti jenis objek dan Kelasmesin.Ini juga memungkinkan Anda untuk membuat banyak snapshot untuk membandingkan perbedaan penggunaan memori seiring waktu.
### [Buat tangkapan layar](#buat-tangkapan-layar)
Untuk membuat snapshot alokasi memori Anda:
1. Buka Konsol Pengembang .
2. Perluas dropdown alat untuk memilih LuauHeap .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/LuauHeap-Open.png' alt='Dropdown menu of all Developer Console tools with the LuauHeap option highlighted for selection.' title='' width='200' height='' />
3. Perluas dropdown klien\-server untuk memilih Klien atau Server .
4. Klik tombol Membuat Snapshot .
### [Analisis penggunaan memori](#analisis-penggunaan-memori)
Alat memberikan lima pandangan yang dapat Anda pilih untuk melihat alokasi memori Luau Anda berdasarkan pandangan yang berbeda:
* Grafik — Menunjukkan pohon penggunaan memori agregat dengan setiap node yang mewakili objek dengan memori yang disediakan
* Tag Objek — Menampilkan ukuran memori dan jumlah oleh jenis runtime, seperti function , table , dan thread .
* Kategori Memori — Menampilkan ukuran dan jumlah memori yang ditugaskan oleh kategori memori mesin.Mesin menugaskan kategori memori ke objek pada saat alokasi.
* Kelas Objek — Menampilkan ukuran memori dan jumlah oleh kelas mesin yang digunakan oleh skrip Anda dan menyimpan instansi mereka, seperti EnumItem , Animation , CFrame .
* Referensi Unik — Menunjukkan hitungan dan total jumlah instans yang tidak memiliki orang tua di model data dan hanya dapat diakses oleh skrip, serta semua jalur yang menempelkan objek instans.
#### [Grafis](#grafis)
Tampilan Grafik paling terperinci dan kompleks di antara semua tampilan heap Luau.Ini menunjukkan pohon penggunaan memori teraggregasi dengan setiap node yang mewakili objek dengan memori yang disediakan.Pohon menunjukkan bagaimana objek terhubung satu sama lain dan menentukan jalur pendek antara referensi objek.Ini memiliki kolom memori berikut dari ukuran memori: Ukuran \- Penggunaan memori diri ditambah penggunaan memori oleh konten di dalam struktur data.Diri sendiri — Memori yang secara langsung disediakan untuk struktur data itu sendiri, mengecualikan penggunaan memori oleh konten apa pun yang terkandung di dalamnya.
Tampilan grafik menampilkan elemen yang lebih kecil dari 2KB sebagai satu node … tunggal.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Graph-View.jpeg' alt='An example Graph view' title='' width='800' height='' />Akar dari grafik pohon adalah registry , yang menyimpan semua referensi mesin dan Luau, seperti fungsi yang terhubung ke sinyal atau perpustakaan tugas, tabel yang dikembalikan oleh skrip modul, dan fungsi global, tabel dan Kelas.Biasanya orang tua memiliki entri umum berikut:
* Module @Path.To.Module adalah tabel yang dikembalikan oleh skrip modul.
* name:123 \=Path.To.Module adalah fungsi di dalam skrip yang ditentukan.Fungsi anonim tidak memiliki nama.Level node tertinggi sering merujuk pada fungsi skrip global.Fungsi anonim tidak memiliki nama.Contoh: :1\= Workspace.\[Username].Animate .
* upvalue adalah referensi untuk fungsi yang ditangkap. Lihat [Tangkap skop lokal](/docs/id-id/luau/scope#capture) untuk informasi lebih lanjut.
* env merujuk pada lingkungan fungsi. Untuk sebagian besar kasus, ini adalah tabel yang mewakili cakupan global skrip.
* globals merujuk pada lingkungan thread.
* \[key] mewakili objek yang berfungsi sebagai kunci meja.
* array mewakili sebuah array.
* stack merujuk pada array yang menyimpan semua lokal fungsi.
* constants mewakili semua nilai konstan yang digunakan fungsi.
#### [Kategori memorisasi](#kategori-memorisasi)
Tampilan Kategori Memori menunjukkan ukuran memori dan jumlahnya oleh kategori memori, yang ditugaskan ke objek saat alokasi waktu.Secara default, kategori memori memiliki nama yang sama dengan skrip, atau Anda dapat menetapkan nama kategori memori khusus menggunakan fungsi debug.setmemorycategory.
#### [Referensi unik](#referensi-unik)
Tampilan Referensi Unik menunjukkan penggunaan memori instansi yang tidak memiliki orang tua di model data dan hanya dapat diakses oleh skrip, serta semua jalur yang menempelkan objek instansi.Pandangan ini memiliki dua metrik:
* Menghitung — Menunjukkan jumlah instansi dengan nama yang sama yang dapat diakses dari jalur yang sama, seperti beberapa instansi bernama Dragon di tabel yang sama.
* Total Instansi — Menunjukkan jumlah total objek di dalam akar itu, seperti semua bagian, skrip, dan objek suara yang membangun kejadianDragon .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/console/Unique-Reference-View.jpeg' alt='An example Unique Reference view' title='' width='800' height='' />Pandangan ini berguna untuk mengidentifikasi instansi terhubung yang tidak perlu, yang perlu Anda putus ketika Anda tidak lagi membutuhkannya.Jika Anda melihat banyak insiden tak terduga dalam pandangan ini, periksa jalur yang menyimpan mereka dan evaluasi apakah mereka diperlukan.
| 44 |
https://create.roblox.com/docs/id-id/studio/quick-access
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Alat akses cepat toolbar
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/quick-access).
Alat bilah akses cepat terkandung toolbar berisi pintasan ke berbagai tindakan dan perintah Studio.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Quick-Access-Toolbar.png' alt='Quick Access Toolbar indicated in Studio toolbar' title='' width='716' height='' />Anda dapat dengan cepat menampilkan atau menyembunyikan tindakan dengan mengklik panah kecil di sebelah kanan bilah alat dan memilih tombol mana yang akan diaktifkan atau dimatikan.Anda juga dapat tambah, menghapus, dan mengubah urutan tombol dengan memilih Sesuaikan dari menu drop\-down.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Quick-Access-Toolbar-Menu.png' alt='Quick Access Toolbar customization menu in Studio' title='' width='716' height='' />Di jendela Kustomisasi Bilah Aksi Cepat , Anda dapat:
* Tambahkan tindakan Studio ke bilah alat.
* Toggle tombol pada atau mati.
* Hapus tindakan dari daftar sepenuhnya.
* Konfigurasi ulang urutan tombol di bilah alat.
| 45 |
https://create.roblox.com/docs/id-id/studio/home-tab
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Tab Rumah
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/home-tab).
Tab Rumah berisi alat dasar untuk membangun dan menguji pengalaman Anda.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Home-Tab.png' alt='Home tab indicated in Studio toolbar' title='' width='716' height='' />
## [Papan Potong](#papan-potong)
Bagian pertama dari kiri berisi alat untuk menyalin, memotong, menempelkan, dan menyalin instansi.Anda dapat melakukan operasi ini pada objek atau instans 3D di dunia atau di jendela [Explorer](/docs/id-id/studio/explorer).
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Lempas | CtrlV (Windows) ⌘V (Mac) | Sisipkan konten klipboard. |
| Menyalin | CtrlC (Windows) ⌘C (Mac) | Salin pilihan saat ini ke clipboard. |
| Pangkas | CtrlX (Windows) ⌘X (Mac) | Potong pilihan saat ini dan letakkan di bilah klip. |
| Duplikasi | CtrlD (Windows) ⌘D (Mac) | Duplikasi pilihan saat ini di tingkat yang sama dalam hierarki. |
## [Alat transformasi](#alat-transformasi)
Alat transformasi utama termasuk Pilih , Pindahkan , Skala , dan Putar .Ketika Anda memilih alat, penggerak visual ditampilkan pada objek yang dipilih di jendela tampilan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Transform-Tools.png' alt='Transform tools indicated in Home tab' title='' width='716' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Move-SM.png' alt='Move draggers shown on part in 3D viewport' title='' width='100%' height='' />
*Pindahkan*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Scale-SM.png' alt='Scale draggers shown on part in 3D viewport' title='' width='100%' height='' />
*Skala*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Rotate-SM.png' alt='Rotate draggers shown on part in 3D viewport' title='' width='100%' height='' />
*Putar*
Alat mengubah peningkatan geser didasarkan pada kancing untuk bergerak/skala atau derajat untuk berputar, masing\-masing dapat disesuaikan di tab [Model](/docs/id-id/studio/model-tab) di bilah alat.Saat mengubah, Anda dapat sementara beralih penyematan dengan menahan unitShift .
Jika objek yang dipilih dan penyeret visualnya saat ini tidak terlihat dalam jendela pandang 3D, Anda dapat menekan tombol Tab untuk "memanggil" penyeret ke posisi mouse Anda, memungkinkan Anda untuk mengubah objek yang dipilih dari sudut pandang Anda saat ini.
### [Mode](#mode)
Pemilih Mode beralih antara transformasi geometris standar dan [simulasi batasan mekanis](/docs/id-id/physics/mechanical-constraints#simulate-constraints) saat memindahkan atau memutar bagian.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Mode.png' alt='Mode selector indicated in Home tab' title='' width='716' height='' />
### [Tabrakan](#tabrakan)
Kotak centang Tabrakan mengubah status tabrakan saat Anda mengubah objek.Jika tabrakan adalah mati , Anda dapat memindahkan, memperbesar, dan memutar objek sehingga mereka tumpang tindih; jika tabrakan adalah pada , Anda tidak dapat mengubah objek untuk tumpang tindih objek lain.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Collisions-On.png' alt='Collisions checkbox indicated in Home tab' title='' width='716' height='' />
### [Transformasi koordinat](#transformasi-koordinat)
CtrlL di Windows atau ⌘L di Mac beralih antara mengubah objek relatif terhadap koordinat dunia atau koordinat lokal objek lokal .Saat dalam mode lokal, simbol L muncul di bagian bawah kanan objek.
Dunia
Lokal
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Move-World-Orientation.png' alt='Part draggers in World orientation mode' title='' width='720' height='405' />
## [Editor Tanah](#editor-tanah)
Tombol Editor membuka jendela dengan alat untuk membuat dan membentuk medan statis. Untuk informasi lebih lanjut, lihat [Editor Medan](/docs/id-id/studio/terrain-editor).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Terrain-Editor.png' alt='Terrain Editor indicated in Home tab' title='' width='716' height='' />
## [Kotak Alat](#kotak-alat)
Kotak Alat termasuk semua model, gambar, mesh, audio, dan banyak lagi yang telah Anda publikasikan, atau yang dipublikasikan oleh kelompok yang Anda miliki.Ini juga termasuk pilihan aset yang dibuat oleh Roblox atau anggota komunitas Roblox.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Toolbox.png' alt='Toolbox indicated in Home tab' title='' width='716' height='' />
## [Inserensi bagian](#inserensi-bagian)
Tombol Bagian memasukkan bagian baru ke dalam ruang kerja.Mengklik panah dropdown kecil di tombol memungkinkan Anda memilih antara Blok , Sfera , Pasak , Sudut Wedge , atau Silinder .Untuk informasi lebih lanjut, lihat [Suku Cadang](/docs/id-id/parts).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Part-Tools.png' alt='Part menu indicated in Home tab' title='' width='716' height='' />
## [Desainer UI](#desainer-ui)
Tombol UI membuka tab yang memungkinkan Anda dengan cepat menyisipkan, mengubah ukuran, dan memindahkan objek UI umum di layar, seperti [Label](/docs/id-id/ui/labels), [Fram](/docs/id-id/ui/frames), dan [Tombol](/docs/id-id/ui/buttons).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-UI.png' alt='UI button indicated in Home tab' title='' width='780' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-UI-Tab.png' alt='UI tab indicated in Studio toolbar' title='' width='780' height='' />
## [Importasi 3D](#importasi-3d)
Alat Impor 3D memungkinkan Anda untuk mengimpor hampir semua jenis .fbx atau .obj dan file teksur terkait ke Studio.Lihat [Impor 3D](/docs/id-id/art/modeling/3d-importer) untuk informasi lebih lanjut.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Import-3D.png' alt='Import 3D button indicated in Home tab' title='' width='780' height='' />
## [widget warna](#widget-warna)
Mengklik panah dropdown kecil di warna widget mengungkapkan pemilih warna hexagonal.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Color-Picker.png' alt='Studio's Home tab with the Color widget's hexagonal picker.' title='' width='776' height='' />Secara default, mengklik tombol keseluruhan Warna menerapkan warna yang dipilih ke setiap bagian dipilih .Jika Anda lebih suka menggunakan alur kerja isi/cat, nyalakan Aksi Warna sebagai Alat dan kemudian klik bagian di jendela 3D untuk menerapkan warna yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Color-Action-As-Tool.png' alt='Studio's Home tab with the Color Action as Tool selector indicated.' title='' width='776' height='' />Untuk cara alternatif untuk menerapkan warna khusus, lihat [Bagian Pewarnaan](/docs/id-id/parts#colors-popup).
## [widget materi](#widget-materi)
Mengklik panah dropdown kecil di Material widget mengungkapkan pemilih [material](/docs/id-id/parts/materials).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Material-Picker.png' alt='Studio's Home tab with the Material widget's picker.' title='' width='776' height='' />Secara default, mengklik tombol keseluruhan Material menerapkan bahan yang dipilih ke setiap bagian terpilih .Jika Anda lebih suka menggunakan alur kerja isi/cat sebagai gantinya, nyalakan Tindakan Bahan sebagai Alat dan kemudian klik bagian di jendela 3D untuk menerapkan bahan yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Material-Action-As-Tool.png' alt='Studio's Home tab with the Material Action as Tool selector indicated.' title='' width='776' height='' />
## [Alat kelompok](#alat-kelompok)
Anda dapat mengelompokkan objek ke dalam model [model](/docs/id-id/parts/models) dengan memilihnya dan mengklik tombol Grup .Tindakan ini memiliki pintasan default dari CtrlG (Windows) atau ⌘G (Mac).
Alternatifnya, Anda dapat menggrupkan objek ke dalam folder dengan mengklik panah kecil di samping tombol dan memilih Group sebagai Folder .Tindakan ini memiliki pintasan default dari AltCtrlG (Windows) atau ⌥⌘G (Mac).
Untuk tidak menggabungkan model atau folder yang ada, klik panah kecil di sebelah tombol dan pilih Tidak menggabungkan .Tindakan ini memiliki pintasan default dari CtrlU (Windows) atau ⌘U (Mac).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Group-Tools.png' alt='Group tools indicated in Home tab' title='' width='776' height='' />
## [Alat kunci](#alat-kunci)
Anda dapat mengaktifkan Alat Kunci dengan mengklik panah kecil di samping tombol Kunci dan memilih Alat Kunci .Tindakan ini memiliki pintasan default dari AltL (Windows) atau ⌥L (Mac).
Setelah diaktifkan, alat berfungsi sebagai "unit" untuk kedua negara \- mengklik objek yang terbuka mengunci itu, sementara mengklik objek yang terkunci membukanya.
Untuk membuka semua objek, klik panah kecil di sebelah tombol dan pilih Buka Semua .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Lock-Tools.png' alt='Lock tools indicated in Home tab' title='' width='776' height='' />
## [Toggle ikat pengunci](#toggle-ikat-pengunci)
Kontrol toggle Anchor apakah bagian akan menjadi tidak dapat dipindahkan oleh fisika.Ketika [Anchored](/docs/id-id/reference/engine/classes/BasePart#Anchored) , bagian tidak akan pernah berubah posisi karena gravitasi, tabrakan bagian lain, penumpangan bagian lain, atau penyebab fisika lainnya.Tindakan ini memiliki pintasan default dari AltA (Windows) atau ⌥A (Mac).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Anchor.png' alt='Anchor toggle indicated in Home tab' title='' width='776' height='' />
## [Opsi pengujian playtest](#opsi-pengujian-playtest)
Ada tiga opsi umum untuk pengujian pengalaman.Mengklik tombol memulai tes permainan mode yang saat ini dipilih, dan mengklik panah kecil di bawah tombol memungkinkan Anda memilih mode yang berbeda.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Playtest-Options.png' alt='Playtest options indicated in Home tab' title='' width='760' height='' />
| Mode | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Mainkan | F5 | Memulai simulasi pengalaman, menyisipkan avatar Anda di [SpawnLocation](/docs/id-id/reference/engine/classes/SpawnLocation) atau koordinat sekitar (0, 100, 0\). |
| Bermain di Sini | | Memulai simulasi pengalaman, menyisipkan avatar Anda di depan posisi kamera saat ini. |
| Jalankan | F8 | Memulai simulasi pengalaman tetapi tidak menyisipkan avatar Anda.Simulasi dimulai dari posisi kamera saat ini dan Anda dapat bernavigasi di sekitar menggunakan kendalikamera Studio. |
Setelah tes permainan dijalankan, opsi berikut menjadi tersedia:
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Playtest-Running-Options.png' alt='Playtest options indicated in Home tab' title='' width='767' height='' />
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Klien/Server | | Selama pengujian permainan dalam mode "bermain sendiri" ( Bermain atau Bermain di sini ), beralih antara mode klien dan mode server .Lihat [Mode Pengujian Studio](/docs/id-id/studio/testing-modes) untuk rincian. |
| Berhenti | ShiftF5 | Menghentikan simulasi pengalaman dan mengatur ulang semua objek dan instans ke bagaimana mereka sebelum Bermain , Bermain di sini , atau Jalankan diklik. |
## [Pengaturan Permainan](#pengaturan-permainan)
Tombol Pengaturan Permainan , yang hanya dapat diakses untuk pengalaman [terbit](/docs/id-id/production/publishing/publish-experiences-and-places) yang dipublikasikan, memungkinkan Anda untuk memperbarui informasi dasar, izin, keamanan, pengaturan avatar, dan banyak lagi.Untuk informasi lebih lanjut, lihat halaman referensi [Pengaturan Permainan](/docs/id-id/studio/game-settings).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Game-Settings.png' alt='Game Settings button indicated in Home tab' title='' width='760' height='' />
## [Pengujian Tim](#pengujian-tim)
Selama sesi kolaboratif [berkolaborasi](/docs/id-id/projects/collaboration), mengklik Tes Tim memulai tes permainan dengan editor lain, dan Keluar dari Permainan keluar dari permainan saat ini.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Team-Test-Options.png' alt='Team Test option buttons indicated in Home tab' title='' width='714' height='' />
| 46 |
https://create.roblox.com/docs/id-id/studio/model-tab
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Tab model
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/model-tab).
Tab Model berisi alat untuk memanipulasi objek 3D di ruang kerja, membuat model terperinci, bekerja dengan batasan fisik, dan menambahkan objek canggih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Model-Tab.png' alt='Model tab indicated in Studio toolbar' title='' width='830' height='' />
## [Alat transformasi](#alat-transformasi)
Alat transformasi utama termasuk Pilih , Pindahkan , Skala , Putar , dan Transformasi .Ketika Anda memilih alat, penyeret visual ditampilkan pada objek yang dipilih di jendela 3D.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Transform-Tools.png' alt='Transform tools indicated in Model tab' title='' width='830' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Move-SM.png' alt='Move draggers shown on part in 3D viewport' title='' width='100%' height='' />
*Pindahkan*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Scale-SM.png' alt='Scale draggers shown on part in 3D viewport' title='' width='100%' height='' />
*Skala*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Rotate-SM.png' alt='Rotate draggers shown on part in 3D viewport' title='' width='100%' height='' />
*Putar*
Alat mengubah peningkatan geser didasarkan pada stud untuk bergerak/skala atau derajat untuk berputar, masing\-masing dapat disesuaikan.Saat mengubah, Anda dapat sementara beralih pengambilan dengan menahan unitShift.
Jika objek yang dipilih dan penyeret visualnya saat ini tidak terlihat dalam jendela pandang 3D, Anda dapat menekan tombol Tab untuk "memanggil" penyeret ke posisi mouse Anda, memungkinkan Anda untuk mengubah objek yang dipilih dari sudut pandang Anda saat ini.
### [Mode](#mode)
Pemilih Mode beralih antara transformasi geometris standar dan [simulasi batasan mekanis](/docs/id-id/physics/mechanical-constraints#simulate-constraints) saat memindahkan atau memutar bagian.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Mode.png' alt='Mode selector indicated in Model tab' title='' width='768' height='' />
### [Tabrakan](#tabrakan)
Kotak centang Tabrakan mengubah status tabrakan saat Anda mengubah objek.Jika tabrakan adalah mati , Anda dapat memindahkan, memperbesar, dan memutar objek sehingga mereka tumpang tindih; jika tabrakan adalah pada , Anda tidak dapat mengubah objek untuk tumpang tindih objek lain.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Collisions-On.png' alt='Collisions checkbox indicated in Model tab' title='' width='768' height='' />
### [Transformasi klikan otomatis](#transformasi-klikan-otomatis)
Peningkatan geser untuk transformasi alat didasarkan pada studs untuk bergerak/skala atau derajat untuk berputar.Untuk mengaktifkan atau menonaktifkan pengambilan:
* Sementara beralih geser baik pada atau mati dengan menahan Shift saat mengubah.
* Toggle kotak centang di samping Putar atau Pindahkan , dan sesuaikan peningkatan rotasi/transformasi melalui bidang input.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Transform-Snapping.png' alt='Transform snapping tools indicated in Model tab' title='' width='768' height='' />
### [Transformasi koordinat](#transformasi-koordinat)
CtrlL di Windows atau ⌘L di Mac beralih antara mengubah objek relatif terhadap koordinat dunia atau koordinat lokal objek lokal .Saat dalam mode lokal, simbol L muncul di bagian bawah kanan objek.
Dunia
Lokal
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Move-World-Orientation.png' alt='Part draggers in World orientation mode' title='' width='720' height='405' />
## [Alat berputar](#alat-berputar)
Alat Pivot memberi Anda kontrol penuh atas titik di sekitar mana objek berputar dan diterjemahkan. Lihat [Alat Pivot](/docs/id-id/studio/pivot-tools) untuk rincian.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Pivot-Tools.png' alt='Pivot Tools indicated in Model tab' title='' width='768' height='' />
## [Alat Penyelarasan](#alat-penyelarasan)
Tombol Alurkan Alat membuka serangkaian alat untuk menyelaraskan objek atau kelompok objek di sepanjang sumbu X, Y, atau Z.Untuk informasi lebih lanjut, lihat [Alat Sesuaikan](/docs/id-id/studio/align-tool).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Align-Tool.png' alt='Align Tool indicated in Model tab' title='' width='660' height='' />
## [Inserensi bagian](#inserensi-bagian)
Tombol Bagian memasukkan bagian baru ke dalam ruang kerja.Mengklik panah dropdown kecil di tombol memungkinkan Anda memilih antara Blok , Sfera , Pasak , Sudut Wedge , atau Silinder .Untuk informasi lebih lanjut, lihat [Suku Cadang](/docs/id-id/parts).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Part-Tools.png' alt='Part menu indicated in Model tab' title='' width='660' height='' />
## [widget warna](#widget-warna)
Mengklik panah dropdown kecil di warna widget mengungkapkan pemilih warna hexagonal.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Color-Picker.png' alt='Studio's Model tab with the Color widget's hexagonal picker.' title='' width='704' height='' />Secara default, mengklik tombol keseluruhan Warna menerapkan warna yang dipilih ke setiap bagian dipilih .Jika Anda lebih suka menggunakan alur kerja isi/cat, nyalakan Aksi Warna sebagai Alat dan kemudian klik bagian di jendela 3D untuk menerapkan warna yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Color-Action-As-Tool.png' alt='Studio's Model tab with the Color Action as Tool selector indicated.' title='' width='704' height='' />Untuk cara alternatif untuk menerapkan warna khusus, lihat [Bagian Pewarnaan](/docs/id-id/parts#colors-popup).
## [widget materi](#widget-materi)
Mengklik panah dropdown kecil di Material widget mengungkapkan pemilih [material](/docs/id-id/parts/materials).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Material-Picker.png' alt='Studio's Model tab with the Material widget's picker.' title='' width='704' height='' />Secara default, mengklik tombol keseluruhan Material menerapkan bahan yang dipilih ke setiap bagian terpilih .Jika Anda lebih suka menggunakan alur kerja isi/cat sebagai gantinya, nyalakan Tindakan Bahan sebagai Alat dan kemudian klik bagian di jendela 3D untuk menerapkan bahan yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Material-Action-As-Tool.png' alt='Studio's Model tab with the Material Action as Tool selector indicated.' title='' width='704' height='' />
## [Pembangkit Textur](#pembangkit-textur)
props.leadIn File \> Fitur Beta \> props.betaName props.leadOutAlat [Pembangkit Teks](/docs/id-id/studio/texture-generator) dengan cepat membuat teks khusus untuk meshes melalui prompt teks.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Texture-Generator.png' alt='Texture Generator indicated in Model tab' title='' width='704' height='' />
## [Alat kelompok](#alat-kelompok)
Anda dapat mengelompokkan objek ke dalam model [model](/docs/id-id/parts/models) dengan memilihnya dan mengklik tombol Grup .Tindakan ini memiliki pintasan default dari CtrlG (Windows) atau ⌘G (Mac).
Alternatifnya, Anda dapat menggrupkan objek ke dalam folder dengan mengklik panah kecil di samping tombol dan memilih Group sebagai Folder .Tindakan ini memiliki pintasan default dari AltCtrlG (Windows) atau ⌥⌘G (Mac).
Untuk tidak menggabungkan model atau folder yang ada, klik panah kecil di sebelah tombol dan pilih Tidak menggabungkan .Tindakan ini memiliki pintasan default dari CtrlU (Windows) atau ⌘U (Mac).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Group-Tools.png' alt='Group tools indicated in Model tab' title='' width='706' height='' />
## [Alat kunci](#alat-kunci)
Anda dapat mengaktifkan Alat Kunci dengan mengklik panah kecil di samping tombol Kunci dan memilih Alat Kunci .Tindakan ini memiliki pintasan default dari AltL (Windows) atau ⌥L (Mac).
Setelah diaktifkan, alat berfungsi sebagai "unit" untuk kedua negara \- mengklik objek yang terbuka mengunci itu, sementara mengklik objek yang terkunci membukanya.
Untuk membuka semua objek, klik panah kecil di sebelah tombol dan pilih Buka Semua .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Lock-Tools.png' alt='Lock tools indicated in Model tab' title='' width='704' height='' />
## [Toggle ikat pengunci](#toggle-ikat-pengunci)
Kontrol toggle Anchor apakah bagian akan menjadi tidak dapat dipindahkan oleh fisika.Ketika [Anchored](/docs/id-id/reference/engine/classes/BasePart#Anchored) , bagian tidak akan pernah berubah posisi karena gravitasi, tabrakan bagian lain, penumpangan bagian lain, atau penyebab fisika lainnya.Tindakan ini memiliki pintasan default dari AltA (Windows) atau ⌥A (Mac).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Anchor.png' alt='Anchor toggle indicated in Model tab' title='' width='704' height='' />
## [Modelingsolid](#modelingsolid)
Bagian Pemodelan Padat berisi alat untuk membuat geometri baru di luar bagian dasar [bagian](/docs/id-id/parts) yang disediakan oleh Roblox.Untuk informasi lebih lanjut, lihat [Pemodelan Solid](/docs/id-id/parts/solid-modeling).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Solid-Modeling.png' alt='Solid modeling tools indicated in Model tab' title='' width='732' height='' />
| Alat | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Persatuan | ShiftCtrlG (Windows) Shift⌘G (Mac) | Bergabung dua atau lebih bagian bersama untuk membentuk satu persatuan padat tunggal. |
| Terpotong | ShiftCtrlI (Windows) Shift⌘I (Mac) | Menyilangkan bagian tumpang tindih ke dalam satu persimpangan padat. |
| Menolak | ShiftCtrlN (Windows) Shift⌘N (Mac) | Tolak bagian, berguna untuk membuat lubang dan indentasi. |
| Terpisah | ShiftCtrlU (Windows) Shift⌘U (Mac) | Pisahkan serikat atau persimpangan kembali ke bagian\-bagian individunya. |
## [Kontraksi fisik](#kontraksi-fisik)
Bagian Batasan berisi alat untuk membuat fisik [Constraints](/docs/id-id/reference/engine/classes/Constraint) antara objek.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Constraints.png' alt='' title='' width='754' height='' />Kontraksi dikategorikan menjadi dua kelompok:
* [Batasan Mekanis](/docs/id-id/physics/mechanical-constraints) — Batasan dalam kelompok ini berperilaku sebagai koneksi mekanik, termasuk engsel, resor, motor, dan tali.
* [Batasan Penggerak](/docs/id-id/physics/mover-constraints) — Batasan dalam kelompok ini menerapkan gaya atau torsi untuk memindahkan satu atau lebih assemblasi
## [Efek dan spawn](#efek-dan-spawn)
Alat bagian Permainan memungkinkan Anda untuk menyisipkan efek indah seperti [lampu](/docs/id-id/environment) dan [pemancar partikel](/docs/id-id/effects/particle-emitters) , serta dengan cepat menyisipkan [SpawnLocation](/docs/id-id/reference/engine/classes/SpawnLocation) ke dalam ruang 3D.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Effects-Spawn.png' alt='Effects and Spawn tools indicated in Model tab' title='' width='754' height='' />
| Tindakan | Deskripsi |
| --- | --- |
| Efek | Membuat cahaya atau efek baru di ruang kerja atau objek yang dipilih. Dropdown memungkinkan Anda untuk memilih jenis efek yang akan dibuat. |
| Memunculkan | Menambahkan [SpawnLocation](/docs/id-id/reference/engine/classes/SpawnLocation) untuk pemain muncul saat mereka bergabung dengan pengalaman. |
## [Opsi lanjutan](#opsi-lanjutan)
Bagian Lanjutan berisi alat untuk menyisipkan objek, layanan, dan skrip canggih, serta mengkonfigurasi [filter kolisi](/docs/id-id/workspace/collisions#collision-filtering).
| Tindakan | Deskripsi |
| --- | --- |
| Sisipkan Objek | Membuka popup **Sisipkan Objek** untuk pemasukan cepat objek. |
| Model | Memungkinkan Anda untuk men导入 a [Model](/docs/id-id/reference/engine/classes/Model) dari file lokal. |
| Layanan | Memungkinkan Anda untuk menyisipkan layanan yang tidak terdaftar di Explorer secara default. |
| Grup Tabrakan | Membuka jendela yang memungkinkan Anda membuat dan mengedit kelompok tabrakan untuk penyaringan tabrakan fisik [.](/docs/id-id/workspace/collisions#collision-filtering) |
| Jalankan Skrip | Menjalankan [Script](/docs/id-id/reference/engine/classes/Script) terletak di file di komputer lokal Anda. |
| Skrip | Memasukkan [Script](/docs/id-id/reference/engine/classes/Script) ke dalam yang dipilih [Instance](/docs/id-id/reference/engine/classes/Instance) . |
| Skrip Lokal | Memasukkan [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) ke dalam yang dipilih [Instance](/docs/id-id/reference/engine/classes/Instance) . |
| Skrip Modul | Memasukkan [ModuleScript](/docs/id-id/reference/engine/classes/ModuleScript) ke dalam yang dipilih [Instance](/docs/id-id/reference/engine/classes/Instance) . Anda dapat menerapkan jenis skripnya untuk menggunakan kembali kode di skrip lain. |
| 47 |
https://create.roblox.com/docs/id-id/studio/avatar-tab
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Tab Avatar
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/avatar-tab).
Tab Avatar berisi alat transformasi standar dan alat khusus untuk membuat dan memasang aksesori, impor meshes kustom, membangun rig default, dan membuat animasi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Avatar-Tab.png' alt='Avatar tab indicated in Studio toolbar' title='' width='844' height='' />
## [Alat aksesori](#alat-aksesori)
Bagian Aksesori berisi alat untuk membuat aksesori berlapis atau kaku dari mesh impor khusus.
| Alat | Deskripsi |
| --- | --- |
| Alat Pemasangan Aksesori | Tes dan sesuaikan meshes pada banyak karakter referensi dan animasi sebelum mengubahnya menjadi [Accessory](/docs/id-id/reference/engine/classes/Accessory).Alat secara otomatis menambahkan titik lampir yang benar dan [Enum.AssetType](/docs/id-id/reference/engine/enums/AssetType) ke aksesori yang dibuat. |
| Buat Aksesori | Cepat mengubah [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) yang dipilih menjadi objek [Accessory](/docs/id-id/reference/engine/classes/Accessory). Lihat jendela [Keluaran](/docs/id-id/studio/output) untuk pesan apa pun mengenai aset. |
## [Importasi 3D](#importasi-3d)
Alat Impor 3D memungkinkan Anda untuk mengimpor hampir semua jenis .fbx atau .obj dan file teksur terkait ke Studio.Lihat [Impor 3D](/docs/id-id/art/modeling/3d-importer) untuk informasi lebih lanjut.
## [Pembangun Rig](#pembangun-rig)
Alat Pembangun Rig memungkinkan Anda menyisipkan rig pra\-dibangun, biasanya untuk tujuan animasi. Untuk informasi lebih lanjut, lihat Pembangun Rig .
## [Pengaturan Avatar](#pengaturan-avatar)
Alat Pengaturan Avatar memungkinkan Anda dengan mudah melihat pratinjau animasi, pakaian, aksesori, dan konstruksi tubuh di model avatar, langsung di Studio.Pencipta item avatar dapat mengunggah dan memverifikasi aset untuk Pasar dari alat ini.Lihat [Pengaturan Avatar](/docs/id-id/avatar-setup) untuk rincian penggunaan.
## [Editor Animasi](#editor-animasi)
Editor Animasi memungkinkan Anda untuk merancang dan mempublikasikan animasi khusus di rig. Untuk informasi lebih lanjut, lihat Editor Animasi .
| 48 |
https://create.roblox.com/docs/id-id/studio/test-tab
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Tab ujian
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/test-tab).
Tab Tes berisi alat untuk menguji dan memperbaiki pengalaman, menyimulasikan banyak klien, dan meniru perangkat atau pengguna yang berbeda dengan kebijakan konten regional.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Test-Tab.png' alt='Test tab indicated in Studio toolbar.' title='' width='840' height='' />
## [Opsi pengujian playtest](#opsi-pengujian-playtest)
Ada tiga opsi umum untuk pengujian pengalaman.Mengklik panah kecil di bawah tombol utama memungkinkan Anda memilih dari setiap opsi, dan menetapkan opsi itu sebagai default.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Playtest-Options.png' alt='Rapid playtest options in Studio.' title='' width='760' height='' />
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Mainkan | F5 | Memulai simulasi pengalaman, menyisipkan avatar Anda di [SpawnLocation](/docs/id-id/reference/engine/classes/SpawnLocation) atau koordinat sekitar (0, 100, 0\). |
| Bermain di Sini | | Memulai simulasi pengalaman, menyisipkan avatar Anda di depan posisi kamera saat ini. |
| Jalankan | F8 | Memulai simulasi pengalaman tetapi tidak menyisipkan avatar Anda.Simulasi dimulai dari posisi kamera saat ini dan Anda dapat bernavigasi di sekitar menggunakan kendalikamera Studio. |
Setelah tes permainan dijalankan, opsi berikut menjadi tersedia:
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Running-Options.png' alt='Additional options available during playtesting in Studio.' title='' width='810' height='' />
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Klien / Server | | Selama pengujian permainan dalam mode "bermain sendiri" ( Bermain atau Bermain di sini ), beralih antara mode Klien dan mode Server .Lihat [Klien/Server Toggle](/docs/id-id/studio/testing-modes#clientserver-toggle) untuk rincian. |
| Pause Fisika / Lanjutkan Fisika | | Memungkinkan Anda [jeda dan lanjutkan fisika](#pause--resume-physics) tanpa menonaktifkan rendering. |
| Berhenti | ShiftF5 | Menghentikan simulasi pengalaman dan mengatur ulang semua objek dan instans ke bagaimana mereka sebelum Bermain , Bermain di sini , atau Jalankan diklik. |
## [Jeda dan lanjutkan fisika](#jeda-dan-lanjutkan-fisika)
Sementara [pengujian permainan](#playtest-options) , tombol Pause Fisika dan Lanjutkan Fisika berguna untuk mendiagnosis adegan dan mekanisme ephemeral, tanpa menonaktifkan rendering.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Pause-Resume-Physics.png' alt='Pause Physics and Resume Physics buttons available during playtesting in Studio.' title='' width='810' height='' />Secara default, menghentikan dan melanjutkan tindakan fisika terhadap klien dan server sebagaimana ditunjukkan oleh notasi Semua .Jika Anda ingin menghentikan atau melanjutkan hanya fisika klien atau server, klik panah kecil di tombol mana pun dan pilih Saat ini .Kemudian, tergantung pada pandangan yang dipilih melalui tombol Client/Server pause atau resume hanya akan bertindak pada sisi simulasi itu.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Pause-Resume-Physics-All-Current.png' alt='Selection arrows for Pause Physics and Resume Physics to toggle between All or Current pause/resume action between client and server physics.' title='' width='810' height='' />Ketika fisika dijeda, Anda dapat melangkah maju 1/60 detik (60 Hz) dengan mengklik tombol Langkah Maju Fisika .Seperti tombol tetangga di sebelah kirinya, mengklik panah kecil memungkinkan Anda beralih antara langkah klien dan/atau server antara Semua atau Saat ini .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Step-Forward-Physics.png' alt='Step Forward Physics button available during playtesting in Studio, only active while physics is paused.' title='' width='810' height='' />Perhatikan rincian teknis berikut dalam kaitannya dengan jeda/lanjutkan fisika:
* Meskipun [Animations](/docs/id-id/reference/engine/classes/Animation) tidak didasarkan pada fisika, tombol bilah alat ini juga membekukan/melanjutkan animasi.
* Mematikan atau melanjutkan fisika tidak memiliki efek pada menjalankan skrip.
* Hanya panggilan balik , , , dan berhenti atau melanjutkan melalui tombol bilah alat ini.Panggilan balas lainnya ( [PreRender](/docs/id-id/reference/engine/classes/RunService#PreRender) , [Heartbeat](/docs/id-id/reference/engine/classes/RunService#Heartbeat) , dan [RenderStepped](/docs/id-id/reference/engine/classes/RunService#RenderStepped) ) terus menembak, mempertahankan fungsionalitas normal dari skrip kamera, visualisasi yang diterjemahkan, dan plugin.
## [Klien dan Server](#klien-dan-server)
Menggunakan opsi Klien dan Server , Anda dapat meluncurkan beberapa sesi Studio, satu bertindak sebagai server dan masing\-masing bertindak sebagai klien.Lihat [Simulasi Multi\-Klien](/docs/id-id/studio/testing-modes#multi-client-simulation) untuk rincian.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Clients-Servers.png' alt='Clients and Servers options indicated in Test tab' title='' width='760' height='' />
## [Emulasi perangkat](#emulasi-perangkat)
Emulator Perangkat memungkinkan Anda untuk meniru berbagai perangkat langsung di Studio, memberikan wawasan tentang bagaimana kontrol bekerja di perangkat seluler, konsol, dan headset VR, serta bagaimana elemen UI di layar ditampilkan pada resolusi dan rasio aspek yang berbeda.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Emulation-Device.png' alt='Device button indicated in Test tab' title='' width='800' height='' />Di mode emulasi, Anda dapat memilih perangkat dari menu dropdown pemilih perangkat di atas jendela pandang 3D untuk meniru perangkat yang kurang kuat dan menguji [pengalaman streaming yang diaktifkan](/docs/id-id/workspace/streaming) di mana konten 3D dinamis memuat dan melepaskan berdasarkan memori yang tersedia.Anda juga dapat menyesuaikan ukuran pandangan dan mengubah orientasi antara mode lanskap dan potret.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Editor-Window-Emulation-Options.png' alt='Emulation options above the 3D viewport' title='' width='840' height='' />
## [Emulasi kontroler](#emulasi-kontroler)
The Emulator Kontroler memungkinkan Anda untuk secara akurat meniru input gamepad langsung di StudioKontroler default adalah gamepad umum, tetapi Anda dapat memilih alternatif untuk perangkat PlayStation, Xbox, dan Quest dari menu pemilih kiri atas.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Emulation-Controllers.png' alt='Emulate Device Controllers button indicated in Test tab' title='' width='840' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Controller-Emulator.png' alt='View of the generic controller in the Controller Emulator.' title='' width='720' height='' />Selama pengujian permainan, Anda dapat mengontrol pengalaman dengan kontroler virtual menggunakan mouse Anda.
Anda juga dapat mengklik Edit mappings di sudut kanan atas untuk melihat dan mengedit peta kunci untuk kontrol virtual, misalnya E untuk [ButtonL2](/docs/id-id/reference/engine/enums/KeyCode#ButtonL2) atau 9 untuk [ButtonA](/docs/id-id/reference/engine/enums/KeyCode#ButtonA) .Peta ini disimpan seperti pengaturan Studio lainnya (per kontroler, per pengguna, per komputer) dan diterjemahkan ke acara gamepad di jendela emulator dan tampilan 3D.
## [Emulator pemain](#emulator-pemain)
Emulator Pemutar memungkinkan Anda menguji berbagai kebijakan [lokalisasi](/docs/id-id/production/localization) dan konten. Lihat [Emulasi Pemutar](/docs/id-id/studio/testing-modes#player-emulation) untuk rincian.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Emulation-Player.png' alt='Player emulator button indicated in Test tab' title='' width='840' height='' />
## [Matikan audio](#matikan-audio)
Tombol Mute memungkinkan Anda untuk membisukan suara dan musik dalam pengalaman .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Test-Tab-Mute.png' alt='Mute button indicated in Test tab' title='' width='840' height='' />
| 49 |
https://create.roblox.com/docs/id-id/studio/view-tab
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Tampilkan tab
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/view-tab).
Tab Tampilan memungkinkan Anda untuk beralih antara berbagai jendela di Studio, mengubah [pengatur pemandangan](#view-selector), dan menyesuaikan [opsi tampilan](#display-options).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-View-Tab.png' alt='View tab indicated in Studio toolbar' title='' width='876' height='' />
## [Jendela dan alat](#jendela-dan-alat)
| Pilihan | Deskripsi |
| --- | --- |
| Penjelajah | Menunjukkan jendela [Explorer](/docs/id-id/studio/explorer) yang berisi pohon hierarkis instans dan layanan di tempat. |
| Propinsi | Menampilkan jendela [Properti](/docs/id-id/studio/properties) yang berisi semua properti objek yang dipilih. |
| Manajer Aset | Aktifkan jendela [Manajer Aset](/docs/id-id/projects/assets/manager) untuk mengelola tempat, gambar, meshes, audio, dan banyak lagi pengalaman. |
| Kotak Alat | Mengubah jendela [Toolbox](/docs/id-id/projects/assets/toolbox) terbuka dan tertutup. |
| Output | Jendela [Output](/docs/id-id/studio/output) menunjukkan kesalahan, peringatan, atau output cetak dari menjalankan skrip. |
| Bar Perintah | Bar perintah [dapat digunakan untuk mengeksekusi kode Luau di luar skrip](/docs/id-id/studio/ui-overview#command-bar). |
| Temukan Semua / Ganti Semua | Menampilkan hasil dari pencarian dengan di Windows atau di macOS. |
| Editor Tanah | Membuka jendela dengan alat untuk [membuat dan membentuk medan](/docs/id-id/studio/terrain-editor) . |
| Pengedit Tag | Membuka jendela dengan alat untuk mendefinisikan, menugaskan, dan mengelola tag untuk digunakan dengan [CollectionService](/docs/id-id/reference/engine/classes/CollectionService). |
## [Lihat Pemilih](#lihat-pemilih)
Widget Pemilih Pandangan memungkinkan Anda dengan mudah beralih di antara 14 pandangan di ruang 3D untuk mendapatkan pandangan sempurna dari kreasi Anda.Mengklik wajah atau sudut selektor apa pun memindahkan kamera ke orientasi itu.Anda juga dapat mengklik dan menyeret widget selektor untuk memindahkannya ke mana pun di jendela pandang 3D.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-View-Selector.png' alt='View Selector tool selected in View tab of Studio' title='' width='782' height='' />Wajah Kembali
Sudut
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Selector-Face.jpg' alt='Back face selected on View Selector widget in 3D viewport' title='' width='800' height='450' />
## [Tampilkan opsi](#tampilkan-opsi)
### [Grid dan wireframe](#grid-dan-wireframe)
Grid visual atau pandangan wireframe dapat diaktifkan melalui tombol di bagian Pengaturan .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Grid-Options.png' alt='Grid and wireframe tools indicated in View tab of Studio' title='' width='782' height='' />Standar
Tampilkan grid
Material jaringan
Rendering wireframe
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Grid-Options-Default.jpg' alt='Default 3D viewport with no grid or wireframe options enabled' title='' width='800' height='' />
### [Keterlihatan UI](#keterlihatan-ui)
Mengubah visibilitas elemen antarmuka pengguna di layar dalam tampilan 3D.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-UI-Visibility.png' alt='UI Visibility toggle indicated in View tab of Studio' title='' width='782' height='' />UI di layar terlihat
UI di layar tersembunyi
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Viewport-UI-Visibility-On.jpg' alt='UI Visibility toggled on (visible) for 3D viewport' title='' width='800' height='360' />
### [Gaya pemilihan](#gaya-pemilihan)
Untuk menampilkan garis besar dan/atau kotak batas di sekitar objek yang dipilih, pilih opsi dari menu Gaya Pilihan .Anda juga dapat menyesuaikan ketebalan, warna, dan aspek lain dari garis dan kotak batas melalui menu Pengaturan Studio .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Selection-Style.png' alt='Selection Style menu indicated in View tab of Studio' title='' width='670' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Selected-Object-Bounding-Box.jpg' alt='Selected part showing both its selection outline and a bounding box' title='' width='800' height='' />Sementara berada di sesi kolaboratif [di Studio](/docs/id-id/projects/collaboration), kotak pengikat hanya muncul bagi Anda, bukan bagi orang lain di sesi.
## [Status](#status)
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Stats-Tools.png' alt='Diagnostic stats tools indicated in View tab of Studio' title='' width='670' height='' />
| Tindakan | Deskripsi |
| --- | --- |
| Status | Menunjukkan statistik pengalaman terperinci. |
| Rendahkan | Menampilkan grafik dan data kinerja terperinci. |
| Fisika | Menampilkan data fisika terperinci. |
| Jaringan | Menampilkan statistik jaringan terperinci. |
| Singkatan | Menunjukkan ringkasan data statistik. |
| Jelas | Menghapus semua statistik dari layar. |
| 50 |
https://create.roblox.com/docs/id-id/studio/plugins-tab
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Tab Plugin
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/plugins-tab).
Tab Plugin berisi alat untuk mengelola [plugin](/docs/id-id/studio/plugins) , mengonfigurasi Pelokalan, dan menemukan audio yang digunakan di seluruh tempat.Plugin yang diinstal juga dapat menambahkan tombol ke tab ini.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Plugins-Tab.png' alt='Plugins tab indicated in Studio toolbar' title='' width='800' height='' />
## [Manajemen Plugin](#manajemen-plugin)
Tombol Manajemen Plugin memungkinkan Anda mengaktifkan/nonaktifkan, update, atau menghapus plugin yang telah [diinstal](/docs/id-id/production/creator-store#find-assets) dari Toko Toko Kreator, sementara tombol Folder Plugin membuka folder sistem lokal yang berisi plugin yang telah [dibuat](/docs/id-id/studio/plugins) atau diinstal secara manual.
## [Lokalisasi](#lokalisasi)
Jendela lokalisasi Alat lokal memungkinkan Anda untuk menguji di berbagai bahasa, mengunduh tabel lokalisasi .csv lokal, dan mengunggah tabel yang dimodifikasi .csv.Untuk informasi lebih lanjut, lihat [Lokalisasi](/docs/id-id/production/localization) .
## [Lihat Suara](#lihat-suara)
Plugin Tampilkan Suara memungkinkan Anda menemukan audio yang digunakan di seluruh tempat dan menggantikan aset audio yang tidak memiliki izin untuk digunakan.Lihat [privasi aset](/docs/id-id/projects/assets/privacy) untuk rincian.
| 51 |
https://create.roblox.com/docs/id-id/studio/script-tab
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Tab naskah
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/script-tab).
Tab Skrip berisi alat untuk menulis dan menguji skrip. Anda hanya dapat mengakses tab ini saat menampilkan atau mengedit skrip.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Script-Tab.png' alt='Script tab indicated in Studio toolbar' title='' width='780' height='' />
## [Navigasikan](#navigasikan)
Bagian Navigasi memungkinkan Anda dengan cepat beralih di antara skrip terbuka mana pun.
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Kembali | ShiftCtrl\- (Windows) Shift⌘\- (Mac) | Navigasi ke skrip terbuka sebelumnya. |
| Kedepan | ShiftCtrl\= (Windows) Shift⌘\= (Mac) | Navigasi ke skrip terbuka berikutnya. |
## [Edit](#edit)
Bagian Edit memungkinkan Anda untuk mencari dan mengedit bagian mana pun dari skrip, serta memilih instansi dalam jendela [Explorer](/docs/id-id/studio/explorer) untuk tindakan massal.Lihat [Jalan pintas Studio](/docs/id-id/studio/shortcuts#script-editor) untuk jalan pintas default yang terikat dengan tindakan ini.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Script-Tab-Edit-Tools.png' alt='Edit tools indicated in Script tab' title='' width='780' height='' />
| Tindakan | Deskripsi |
| --- | --- |
| Temukan | Membuka menu pop\-up dengan alat berikut:* **Temukan** — Menemukan semua instansi input Anda di skrip.: * **Temukan Berikutnya** — Menemukan pertandingan berikutnya yang ditemukan di widget "Temukan.": * **Temukan Sebelumnya** — Menemukan pertandingan sebelumnya yang ditemukan di widget "Temukan".: * **Temukan Semua** — Mencari semua instansi input Anda di dalam tempat, bahkan di luar skrip yang saat ini dipilih.: * **Pergi ke Baris** — Menavigasi ke baris tertentu dalam skrip.: * **Buka Cepat** — Mencari semua instansi di jendela [Explorer](/docs/id-id/studio/explorer).: * **Tindakan Buka Cepat** — Mencari semua tindakan Studio.: * **Filter Fungsi Skrip Terbuka** — Mencari semua fungsi dalam skrip aktif dan skrip modul yang diperlukannya. |
| Gantikan | Memungkinkan Anda mengganti satu (atau semua) pertandingan dalam skrip dengan string baru. |
| Pilih | Membuka menu pop\-up dengan alat berikut:* **Pilih Semua** — Memilih semua konten skrip.: * **Pilih Anak\-Anak** — Memilih semua keturunan instans yang dipilih di jendela Explorer. |
## [Bentuk](#bentuk)
Bagian Format memungkinkan Anda untuk memformat bagian atau seluruh skrip untuk dibaca.Dropdown memungkinkan Anda memilih antara Pilihan Format atau Dokumen Format .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Script-Tab-Format-Options.png' alt='Format options indicated in Script tab' title='' width='780' height='' />
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Pemilihan Format | AltShiftF (Windows) ⌥ShiftF (Mac) | Format bagian skrip yang saat ini dipilih dengan tata letak dan indenasi yang tepat. |
| Dokumen Bentuk | | Format seluruh skrip terlepas dari pilihan saat ini. |
## [Jeda dan lanjutkan skrip](#jeda-dan-lanjutkan-skrip)
Selama pengujian permainan, tombol Pause Skrip dan Lanjutkan Skrip berguna untuk menghentikan kedua skrip dan rendering, tanpa [menghentikan fisika](/docs/id-id/studio/test-tab#pause-and-resume-physics).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Script-Tab-Pause-Resume-Scripts.png' alt='Pause Scripts and Resume Scripts buttons available during playtesting in Studio.' title='' width='723' height='' />
## [Alat depurasi](#alat-depurasi)
Bagian debugger memungkinkan Anda mengontrol [debugger](/docs/id-id/studio/debugging).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Script-Tab-Debugging-Tools.png' alt='Debugging tools indicated in Script tab' title='' width='663' height='' />
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Langkah Masuk | F11 | Pindahkan debugger ke fungsi di baris saat ini. Jika tidak ada fungsi di baris saat ini, debugger pindah ke baris berikutnya. |
| Langkah di Atas | F10 | Pindahkan debugger ke baris kode berikutnya, tidak bergerak ke fungsi. |
| Langkah Keluar | ShiftF11 | Pindahkan debugger keluar dari fungsi saat ini dan ke baris kode berikutnya setelah fungsi awalnya dipanggil.Jika baris saat ini tidak berada di dalam fungsi, debugger pindah ke baris berikutnya. |
Anda dapat memilih untuk memperlakukan kesalahan skrip sebagai titik istirahat impromptu.
| Tindakan | Deskripsi |
| --- | --- |
| Tidak pernah | Mematikan debugging skrip impromptu. |
| Pada Semua Pengecualian | Menandai semua kesalahan, bahkan yang terjadi di dalam pcall. |
| Pada Pengecualian yang Tidak Ditangani | Hanya menandai kesalahan yang terjadi dalam mode terlindung; debugger mengabaikan kesalahan yang terjadi di dalam pcall. |
## [Tindakan lain](#tindakan-lain)
Bagian Tindakan paling kanan berisi tindakan skrip lain\-lain.
| Tindakan | Jalan pintas | Deskripsi |
| --- | --- | --- |
| Pergi ke Kesalahan Skrip | | Memindahkan kursor ke instans pertama dari kesalahan dalam skrip Anda. |
| Muat Ulang Skrip | CtrlR (Windows) ⌘R (Mac) | Menerapkan perubahan apa pun yang telah dibuat ke skrip ke tes permainan aktif.Perubahan tidak disimpan ke skrip di luar pengujian permainan kecuali pengaturan Studio Anda diatur ke penyimpanan otomatis perubahan skrip runtime atau Anda mengkonfirmasi untuk menyimpan perubahan setelah menghentikan pengujian permainan.Tindakan ini hanya tersedia saat pengujian permainan. |
| Komitasi | | Melewati setiap perubahan pada skrip sehingga skrip yang diperbarui tersedia untuk pengembang lain dalam tim Anda.Tindakan ini hanya tersedia selama sesi [kolaboratif](/docs/id-id/projects/collaboration). |
| Aktifkan Komentar | Ctrl/ (Windows) ⌘/ (Mac) | Mengubah apakah baris skrip adalah komentar atau tidak. |
| Perluas Semua Lipatan | CtrlE (Windows) ⌘E (Mac) | Memperluas semua lipatan yang runtuh di skrip. |
| Lipat Semua Jatuh | ShiftCtrlE (Windows) Shift⌘E (Mac) | Menggulung semua bagian lipat dari skrip. |
| 52 |
https://create.roblox.com/docs/id-id/studio/explorer
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Jendela explorer
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/explorer).
Jendela Penjelajah menunjukkan daftar hierarkis dari setiap instansi dalam pengalaman.Pada tingkat hierarki tertinggi adalah layanan; [Workspace](/docs/id-id/reference/engine/classes/Workspace) , misalnya, adalah tempat di mana konten 3D yang terlihat seperti [bagian](/docs/id-id/parts) disimpan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Explorer.png' alt='Explorer toggle button in Studio' title='' width='876' height='' />
## [Hierarki orangtua\-anak](#hierarki-orangtua-anak)
Semua anak dari objek orang tua muncul di bawah cabangnya saat diperluas.Klik panah di samping cabang orangtua (atau tekan → / ← ketika cabang orangtua dipilih) untuk memperluas/melipatkan hanya cabang itu.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Parent-Child-Hierarchy.png' alt='Explorer hierarchy showing Camera, Terrain, and SignModel as children of Workspace; Board and Post as children of SignModel' title='' width='320' height='' />
*Hierarki objek terkait*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Branch-Expanded.png' alt='Only the topmost parent expanded with click' title='' width='320' height='' />
*Panah atau → / ← memperluas/melipatkan cabang*
Untuk memperluas atau menyusutkan semua cabang dalam hierarki multi\-terkait, tahan Shift saat mengklik panah ekspansi/penyusutan.
Untuk mengubah orangtua dari satu atau lebih anak (reparent), cukup seret dan lepaskan ke orangtua baru.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Reparent-Object.png' alt='Dragging one object over another to reparent it' title='' width='320' height='' />
## [Pemasukan objek](#pemasukan-objek)
Sementara bagian\-bagian primitif dapat dimasukkan dari tab Rumah atau Model , Anda dapat memilih dari kumpulan objek penuh dengan mengarahkan kursor ke atas orang tua yang dimaksud dan mengklik tombol ⊕ (pendekatan dari di Windows atau di macOS).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Workspace-Add-Object.png' alt='Hovering over Workspace object to reveal insertion button' title='' width='320' height='' />Anda dapat lebih lanjut menyesuaikan perilaku penyisipan dengan mengklik tombol ⋯ di sebelah kanan bidang pencarian:
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Insert-Object-Options.png' alt='Additional customization options for insertion workflow' title='' width='320' height='' />
| Pilihan | Deskripsi |
| --- | --- |
| Nama peningkatan untuk instans baru | Saat diaktifkan, instans insersi/lekat/duplikasi dari jenis yang sama akan memiliki nama berurutan untuk diferensiasi. |
| Perluas hierarki saat memilih | Saat diaktifkan, menyisipkan/menempelkan instansi atau memilih objek di [jendela 3D](/docs/id-id/studio/ui-overview#3d-viewport) akan memperluas hierarki Explorer untuk mengungkapkan kejadianitu.Saat dinonaktifkan, orang tua tingkat atas dalam hierarki akan disorot, tetapi tidak akan memperluas untuk mengungkapkan kejadianyang dipilih. |
Untuk menjaga hierarki lebih bersih, layanan seperti [VoiceChatService](/docs/id-id/reference/engine/classes/VoiceChatService) disembunyikan secara default.Anda dapat menampilkan layanan tersembunyi dengan mengklik kanan di atas layanan yang terlihat dan memilih Tampilkan Layanan... dari menu konteks.Demikian pula, Anda dapat menyembunyikan layanan yang terlihat dengan mengklik kanan dan memilih Sembunyikan Layanan di Explorer .
## [Duplikasi dan paste](#duplikasi-dan-paste)
Objek dapat dengan cepat di複製 ke cabang yang sama, sementara item yang disalin ke clipboard dapat dipaste ke tingkat atas [Workspace](/docs/id-id/reference/engine/classes/Workspace) atau langsung ke satu atau lebih banyak orang tua yang ada.
| Tindakan | Jendela | macOS | Deskripsi |
| --- | --- | --- | --- |
| Duplikasi | CtrlD | ⌘D | Mengulangkan objek yang dipilih ke cabang yang sama. |
| Lempas | CtrlV | ⌘V | Menempelkan konten klip ke cabang tingkat atas [Workspace](/docs/id-id/reference/engine/classes/Workspace) . |
| Lemparkan ke | CtrlShiftV | ⌘ShiftV | Menempelkan konten klip ke objek yang dipilih (s).Menggunakan tindakan ini pada beberapa objek yang dipilih adalah cara yang nyaman untuk menempelkan item clipboard yang sama ke beberapa orang tua, seperti [Texture](/docs/id-id/reference/engine/classes/Texture) umum ke beberapa [Parts](/docs/id-id/reference/engine/classes/Part) berbeda. |
Saat menempelkan objek 3D yang disalin ke clipboard, Anda dapat mempertahankan posisi asli mereka [CFrame](/docs/id-id/reference/engine/datatypes/CFrame) dengan mengklik kanan instans orang tua target di hierarki dan memilih Opsi Tempel \> Tempel ke Lokasi Asli .
## [Organisasi folder](#organisasi-folder)
Seperti direktori/ folder di komputer, objek [Folder](/docs/id-id/reference/engine/classes/Folder) adalah cara yang berguna untuk mengatur objek.Sebagai kejadian, jika Anda ingin menyimpan semua aset audio lingkungan di tempat logis, Anda dapat membuat folder dan menempatkan beberapa objek [AudioPlayer](/docs/id-id/reference/engine/classes/AudioPlayer) di dalamnya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Folder-Children.png' alt='Multiple Sound objects grouped inside a Folder object' title='' width='320' height='' />Anda dapat mengatur objek ke dalam folder sebagai berikut:
* Buat instansi [Folder](/docs/id-id/reference/engine/classes/Folder) melalui metode [insersi](#object-insertion) standar, lalu seret dan lepaskan objek yang ada ke dalamnya.
* Pilih beberapa objek, klik kanan mereka, lalu pilih Grup sebagai Folder dari menu konteks (pendekatan dari di Windows atau di macOS).
## [Metode pencarian](#metode-pencarian)
Melalui input pencarian dekat bagian atas jendela, Anda dapat menemukan instansi dengan nama , properti , kelas/subkelas/tag khusus , dan keturunan pencarian.Anda juga dapat [menggabungkan parameter](#combined) untuk pencarian logis lanjutan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Search-Diagram.png' alt='Example search query and search options' title='' width='360' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-A.png' alt='' title='' width='40' height='' />Navigasikan ke atas dan ke bawah melalui hasil pencarian
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-B.png' alt='' title='' width='40' height='' />Pilih semua hasil pencarian ( CtrlA di Windows atau ⌘A di macOS)
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-C.png' alt='' title='' width='40' height='' />Perbarui hasil pencarian
Sebuah nama adalah serangkaian karakter yang alfanumerik, \_ , \- , atau . .Dalam semua metode pencarian berikut, latih kewaspadaan saat mencari instansi yang nama mereka berisi spasi, karena logika pencarian dapat membingungkan spasi untuk pencarian gabungan .Saat mencari nama dengan spasi, Anda harus mengelilingi nama lengkap dengan tanda kutip ganda, misalnya tag:"Light Source" untuk mencari dengan nama lengkap [tag](/docs/id-id/studio/properties#instance-tags) dari Light Source ..
### [Pencarian nama](#pencarian-nama)
Mengetik di string dasar menghasilkan nama instans yang cocok, tidak sensitif huruf besar/kecil.Sebagai contoh, pencarian dengan kata kunci script menemukan semua instansi yang mengandungnya, seperti ServerScriptService dan LocalScript .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Search-By-Name.png' alt='Objects filtered by query of 'script'' title='' width='320' height='' />
### [Pencarian properti](#pencarian-properti)
Anda dapat menyaring oleh kesamaan properti atau perbandingan nilai.Sebagian besar properti didukung, bekerja dengan pertandingan parsial, mengabaikan spasi, dan tidak sensitif kasus.
Kesetaraan
Perbandingan Nilai
Bidang Individual
Unit Lengkap
Properti kesamaan dicari melalui operator \= atau \=\=.
| Contoh | Hadiah |
| --- | --- |
| Locked \= true | [BaseParts](/docs/id-id/reference/engine/classes/BasePart) dengan [Locked](/docs/id-id/reference/engine/classes/BasePart#Locked) diatur ke true . |
| Material \=\= plas | [BaseParts](/docs/id-id/reference/engine/classes/BasePart) dengan [Material](/docs/id-id/reference/engine/classes/BasePart#Material) dari [Plastic](/docs/id-id/reference/engine/enums/Material) atau [SmoothPlastic](/docs/id-id/reference/engine/enums/Material) . |
### [Pencarian khusus](#pencarian-khusus)
Kelas, dan subkelas, dan tag dicari melalui berbagai pertanyaan khusus pencarian, termasuk:
* dan keduanya menemukan semua yang berada di kelas .Sebagai contoh, classname:Part menemukan semua yang merupakan [Part](/docs/id-id/reference/engine/classes/Part) .
* is:\[SubClass] menemukan semua yang merupakan subkelas dari \[SubClass].Sebagai contoh, is:BasePart menemukan semua yang merupakan subkelas dari [BasePart](/docs/id-id/reference/engine/classes/BasePart) , seperti [Part](/docs/id-id/reference/engine/classes/Part) dan [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) .
* tag:\[TagName] menemukan semuanya dengan tag [CollectionService](/docs/id-id/reference/engine/classes/CollectionService) dari \[TagName].Sebagai contoh, tag:LightSource menemukan semua yang ditagih LightSource .Anda dapat menambahkan tag menggunakan bagian Tag dari properti instansi, atau Editor Tag Studio , dan nama tag akan diselesaikan secara otomatis.
### [Pencarian keturunan](#pencarian-keturunan)
Anda dapat mencari dalam lingkup tertentu menggunakan operator . , operator rantai bersama\-sama untuk pencarian yang sangat spesifik, atau gunakan \* sebagai wildcard.
* \[Parent].\[Child] menemukan anak\-anak bernama di dalam orang tua yang diberi nama.Sebagai contoh, workspace.Model menemukan instansi bernama Model di dalam instansi bernama workspace , mirip dengan scripting.
* Operasi berantai . menambahkan spesifikasi. kejadian, Animals.Dog.Tail menemukan objek bernama Tail di dalam Dog di dalam Animals .
* \* bertindak sebagai wildcard, kejadian:
| Contoh | Hadiah |
| --- | --- |
| Cart.\* | Semua anak dari objek bernama Cart . |
| Cart.Barrier.\* | Semua anak dari Barrier , sendiri anak dari Cart . |
| Cart.\*.\* | Semua cucu dari Cart , mengecualikan anak\-anak langsung dari Cart . |
| Cart.\*.Trim | Semua cucu dari Cart yang bernama Trim . |
* \[Parent]. \*\* menemukan semua keturunan dari orang tua. Misalnya, CarModel.\*\* menemukan semua keturunan dari CarModel.
### [Dikombinasikan](#dikombinasikan)
Untuk pencarian logis lanjutan, Anda dapat menggabungkan pencarian melalui serikat dan grup.
* Banyak pencarian terpisah oleh spasi atau and beroperasi pada semua kondisi.
| Contoh | Hadiah |
| --- | --- |
| Anchored\=true CanCollide\=true | Setiap [BasePart](/docs/id-id/reference/engine/classes/BasePart) yang diikat dan dapat bertabrakan. |
| Cart.\*.\* Transparency \< 1 | Semua cucu dari Cart yang tidak sepenuhnya transparan. |
| Anchored\=false and CanCollide\=false | Setiap [BasePart](/docs/id-id/reference/engine/classes/BasePart) yang tidak diikat dan tidak dapat bertabrakan. |
* Konjungsi or beroperasi seperti operator or dalam kode.Kelompok dalam kurungan, digabungkan oleh or , menemukan semuanya dalam beberapa kueri gabungan.
| Contoh | Hadiah |
| --- | --- |
| Cat or Dog | Semua yang memiliki Cat atau Dog dalam namanya. |
| (Anchored\=true CanCollide\=true) or (Anchored\=false CanCollide\=false) | Setiap [BasePart](/docs/id-id/reference/engine/classes/BasePart) yang entah diikat dan dapat bertabrakan, atau tidak diikat dan tidak dapat bertabrakan. |
## [Metode pemilihan](#metode-pemilihan)
Dalam hierarki [dicari](#search-methods) tertentu, beberapa pintasan kunci dan operasi mouse berperilaku berbeda dari yang mereka lakukan dalam hierarki yang tidak dicari.
### [Pilih semua](#pilih-semua)
Dalam hierarki yang tidak dicari, menekan CtrlA di Windows atau ⌘A di macOS memilih semua instansi.Dalam hierarki [dicari](#search-methods) , jalan pintas yang sama atau tombol pilih semua memilih hanya objek yang cocok dengan kueri.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Select-All-Searched.png' alt='Image showing how only matching objects are selected in a searched hierarchy using the Select All shortcut' title='' width='320' height='' />
### [Shift\-pilih](#shift-pilih)
Dalam hierarki yang tidak dicari, mengklik objek dan Shift \-mengklik objek lain memilih setiap orang tua dalam rentang.Dalam hierarki dicari jika kedua objek yang diklik awalnya dan objek yang diklik bertepatan dengan pencarian, hanya objek pencocokan pencarian yang dipilih di antara.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Shift-Click-Searched.png' alt='Image showing how only matching objects in range are selected within a searched hierarchy' title='' width='320' height='' />
### [Seret pilih](#seret-pilih)
Mengklik dan seret dari sisi kanan jendela memulai kotak pilihan.Dalam hierarki yang tidak dicari, semua yang ada di dalam kotak dipilih.Dalam hierarki [dicari](#search-methods) , hanya objek pencocokan pertanyaan di dalam kotak yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Drag-Select-Searched.png' alt='Image showing how only matching objects inside the selection box are selected within a searched hierarchy' title='' width='320' height='' />
## [Jalan pintas kunci tambahan](#jalan-pintas-kunci-tambahan)
| Jalan pintas | Deskripsi |
| --- | --- |
| → | Dengan cabang yang runtuh dipilih, memperluas cabang itu. Saat ditekan lagi, memilih anak pertama pertama langsung di bawah node orang tua. |
| ← | Dengan anak cabang yang dipilih, pilihan bergerak kembali ke node orangtua. Saat ditekan lagi, seluruh cabang runtuh. |
| home | Memilih objek teratas dalam hierarki ( [Workspace](/docs/id-id/reference/engine/classes/Workspace) ). |
| end | Memilih objek terbawah di hierarki. |
| page up | Memilih objek dalam hierarki yang berada di atas item hierarki teratas terlihat . |
| page down | Memilih objek dalam hierarki yang berada di bawah item hierarki terendah terlihat . |
| 53 |
https://create.roblox.com/docs/id-id/studio/properties
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Jendela properti
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/properties).
Jendela properti yang dapat diakses dari tab [Tampilan](/docs/id-id/studio/view-tab), memungkinkan Anda untuk menyesuaikan properti tertentu dari objek yang dipilih untuk mengubah tampilan dan perilaku objek.Selain itu, Anda dapat mengelola [tag](#instance-tags) dan mengonfigurasi instance [attribut](#instance-attributes) di bagian bawah jendela
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Properties.png' alt='Properties toggle button in Studio' title='' width='876' height='' />
## [Bar judul](#bar-judul)
Ketika Anda memilih objek, bilah judul jendela berubah untuk mencerminkan kelas dan nama objek.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Header-Example-A.png' alt='' title='' width='320' height='' />
*A [Model](/docs/id-id/reference/engine/classes/Model) bernama StoneColumn*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Header-Example-B.png' alt='' title='' width='320' height='' />
*A [Script](/docs/id-id/reference/engine/classes/Script) bernama CandleFlicker*
## [Organisasi bagian](#organisasi-bagian)
Jendela Properti membagi properti objek menjadi bagian.Sebagai contoh, a [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) termasuk bagian seperti Penampilan dan Transformasi yang masing\-masing memungkinkan Anda untuk mengubah penampilannya dan mengubah asalnya, [Size](/docs/id-id/reference/engine/classes/BasePart#Size) , dan [CFrame](/docs/id-id/reference/engine/classes/BasePart#CFrame).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Sections-Example.png' alt='' title='' width='320' height='' />Anda dapat melipat atau memperluas bagian atau subbagian mana pun dengan mengklik panah kecil di sebelah kiri namanya.Setelah Anda memperluas atau melipat bagian, bagian tersebut tetap diperluas atau tertutup untuk objek lain dari kelas yang sama, serta objek terkait yang berbagi kelompok properti yang sama.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Section-Expand-Collapse.png' alt='' title='' width='320' height='' />
## [Perluas input](#perluas-input)
Beberapa properti runtuh secara default, tetapi Anda dapat memperluasnya dengan mengklik panah kecil di sebelah namanya.Sebagai kejadian, [BaseParts](/docs/id-id/reference/engine/classes/BasePart) berisi properti Posisi yang mewakili koordinat X, Y, Z di dunia 3D.Di Studio, koordinat ini dapat dimasukkan dengan dua cara:
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Input-Combined.png' alt='' title='' width='320' height='' />
*Ketiga koordinat ditulis ke bidang orangtua Ukuran , dipisahkan oleh koma*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Input-Expanded.png' alt='' title='' width='320' height='' />
*Properti diperluas dan vektor ukuran individu ditulis ke bidang X , Y , dan Z*
Setelah Anda memperluas atau melipatkan properti, properti tersebut tetap diperluas atau tertutup untuk objek lain dari kelas yang sama, serta objek terkait yang berbagi properti yang sama.
## [Filter properti](#filter-properti)
Anda dapat menyaring properti dengan mengetikkan kueri pencarian ke dalam input Filter Properti di dekat bagian atas jendela.Sebagai contoh, filtering oleh huruf "velo" menemukan semua properti yang mengandungnya, seperti AssemblyLinear Velo kota dan AssemblyAngular Velo kota .Cepat mengakses input ini dengan menekan CtrlShiftP ( ⌘ShiftP ).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Instance-Filtered.png' alt='' title='' width='320' height='' />
## [Tag instansi](#tag-instansi)
Bagian Tag memungkinkan Anda untuk menerapkan tag khusus untuk digunakan dengan [CollectionService](/docs/id-id/reference/engine/classes/CollectionService) .Label adalah set string yang diterapkan ke instansi yang bereplikasi dari server ke klien.Mereka juga diserialisasi saat tempat disimpan.
Untuk menambahkan tag ke instans melalui jendela Properti :
1. Pilih kejadian, gulir ke bagian Tag , dan klik tombol \+ .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Add-Tag-Button.png' alt='' title='' width='320' height='' />
2. Di jendela popup, masukkan nama tag baru atau pilih tag yang sudah Anda buat untuk instans lain dari daftar di bawah bidang input.Label akan muncul di bagian Tag .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Set-Tag.png' alt='' title='' width='320' height='' />
3. Jika diperlukan, Anda dapat menghapus tag yang ada dengan mengklik ikon × .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Remove-Tag-Button.png' alt='' title='' width='320' height='' />
## [Atribut instansi](#atribut-instansi)
Atribut memungkinkan Anda untuk menyesuaikan instans dengan data Anda sendiri.Mereka mirip dengan properti objek bawaan, tetapi Anda dapat membuat dan memodifikasi atribut Anda sendiri untuk setiap kejadian.Fitur kunci termasuk:
* Atribut dapat dibuat, diedit, dan dihapus langsung di jendela Properti , atau melalui [skrip](#scripting).
* Atribut dan nilainya disimpan dengan tempat dan aset Anda.
* Perubahan nilai dapat dilihat secara real time dan direplikasi sehingga klien dapat mengaksesnya segera.
Attribut adalah alat yang bagus untuk membantu Anda dengan cepat mengulang dan menyempurnakan pengalaman Anda.Menggunakan atribut, Anda dapat mengekspos parameter penting sehingga siapa pun di tim dapat menguji berbagai nilai tanpa memerlukan pemahaman lengkap tentang kode dasar.
Contoh penggunaan atribut termasuk:
* Senjata dengan atribut seperti kerusakan, beri ratingtembak, suara tembak, dan waktu isi ulang.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Attributes-Example-A.png' alt='' title='' width='320' height='' />
* Pengujian kendaraan seperti akselerasi dan kecepatan tertinggi, warna tubuh, dan suara mesin.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Attributes-Example-B.png' alt='' title='' width='320' height='' />
* Paket tambahan [atau metadata aset seperti deskripsi, versi, dan penulis](/docs/id-id/projects/assets/packages).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Attributes-Example-C.png' alt='' title='' width='320' height='' />
### [Tipe yang didukung](#tipe-yang-didukung)
Anda dapat menyimpan jenis/nilai berikut di atribut:
* [string](/docs/id-id/luau/strings)
* [boolean](/docs/id-id/luau/booleans)
* [nomor](/docs/id-id/luau/numbers) \>
* [UDim](/docs/id-id/reference/engine/datatypes/UDim) \>
* [UDim2](/docs/id-id/reference/engine/datatypes/UDim2)
* [BrickColor](/docs/id-id/reference/engine/datatypes/BrickColor)
* [Color3](/docs/id-id/reference/engine/datatypes/Color3)
* [Vector2](/docs/id-id/reference/engine/datatypes/Vector2)
* [Vector3](/docs/id-id/reference/engine/datatypes/Vector3)
* [EnumItem](/docs/id-id/reference/engine/datatypes/EnumItem)
* [NumberSequence](/docs/id-id/reference/engine/datatypes/NumberSequence)
* [ColorSequence](/docs/id-id/reference/engine/datatypes/ColorSequence)
* [NumberRange](/docs/id-id/reference/engine/datatypes/NumberRange)
* [Rect](/docs/id-id/reference/engine/datatypes/Rect)
* [Font](/docs/id-id/reference/engine/datatypes/Font)
* [CFrame](/docs/id-id/reference/engine/datatypes/CFrame)
### [Penggunaan studio](#penggunaan-studio)
Atribut baru dapat dibuat dan dimodifikasi di Studio sebagai berikut:
1. Pilih kejadian, gulir ke bagian bawah jendela Properti , dan klik tombol \+ .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Add-Attribute-Button.png' alt='' title='' width='320' height='' />
2. Di jendela popup, masukkan atribut Nama , pilih Jenisnya , dan klik Simpan .
3. Atribut baru akan muncul dengan nilai default yang dapat Anda ubah seperti properti lainnya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Set-Attribute.png' alt='' title='' width='320' height='' />
4. Jika diperlukan, Anda dapat mengganti nama atau menghapus atribut dengan mengklik ikon peralatan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Rename-Delete-Attribute-Button.png' alt='' title='' width='320' height='' />
### [Pemograman](#pemograman)
Bagian dari daya tarik atribut khusus adalah Anda dapat menggunakan skrip untuk memanipulasi mereka. Lihat [Properti dan Atribut](/docs/id-id/scripting/attributes).
| 54 |
https://create.roblox.com/docs/id-id/studio/game-settings
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Pengaturan Permainan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/game-settings).
Jendela Pengaturan Permainan berisi semua pengaturan dan opsi kustomisasi tingkat Studio untuk pengalaman Roblox, termasuk pengaturan untuk [izin](#permissions), [monetarisasi](#monetization), [keamanan](#security), dan [lokalisasi](#localization).Anda dapat mengaksesnya dari tab [Rumah](/docs/id-id/studio/home-tab) di bilah alat.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Home-Tab-Game-Settings.png' alt='Game Settings button indicated in Home tab' title='' width='760' height='' />Jendela Pengaturan Permainan hanya tersedia untuk pengalaman disimpan atau [dipublikasikan](/docs/id-id/production/publishing/publish-experiences-and-places) ke Roblox.
## [Informasi Dasar](#informasi-dasar)
Tab Informasi Dasar berisi pengaturan umum untuk pengalaman, seperti namanya, deskripsinya, dan gambar promosi.
| Pengaturan | Deskripsi |
| --- | --- |
| Nama | Judul pengalaman. |
| Deskripsi | Deskripsi pengalaman yang menjelaskan apa yang seorang pemain potensial harapkan. |
| Label Kematangan Konten | [Label Kematangan Konten](/docs/id-id/production/promotion/content-maturity) memberikan informasi tentang halaman utama pengalaman tentang jenis konten apa pengalaman itu berisi. |
| Ikon Permainan | Memungkinkan Anda mengunggah [ikon](/docs/id-id/production/publishing/experience-icons) untuk mewakili pengalaman Anda. |
| Captur layar \& Video | Memungkinkan Anda mengunggah [thumbnail promosi](/docs/id-id/production/publishing/thumbnails) . |
| Perangkat yang Dapat Dimainkan | Memungkinkan Anda untuk mengaktifkan setiap perangkat yang sesuai yang mendukung pengalaman Anda. |
## [Komunikasi](#komunikasi)
| Pengaturan | Deskripsi |
| --- | --- |
| Aktifkan Mikrofon | Mengaktifkan pengguna yang memenuhi syarat suara untuk menggunakan obrolan suara dalam pengalaman Anda. Lihat [Obrolan Suara](/docs/id-id/chat/voice-chat) untuk informasi lebih lanjut. |
| Aktifkan Kamera | Mengaktifkan pengguna yang memenuhi syarat untuk menganimasikan avatar mereka dengan kamera di pengalaman Anda. Lihat [Animasikan Avatar Anda](https://en.help.roblox.com/hc/en-us/articles/17877687557396) untuk informasi lebih lanjut. |
## [Izin](#izin)
Tab Izin memungkinkan Anda mengontrol audiens untuk pengalaman Anda.
| Pengaturan | Deskripsi |
| --- | --- |
| Dapat Dimainkan | Set yang pengguna dapat mengakses pengalaman. |
## [Monetarisasi](#monetarisasi)
Tab Monetarisasi berisi pengaturan yang memungkinkan Anda [memonetarisasi](/docs/id-id/production/monetization) pengalaman Anda.
| Pengaturan | Deskripsi |
| --- | --- |
| Lencana | Memungkinkan Anda membuat dan mengelola semua [lencana](/docs/id-id/production/publishing/badges) untuk pengalaman Anda. |
| Akses Berbayar | Memungkinkan Anda untuk mengaktifkan akses berbayar di Robux atau akses berbayar di mata uang lokal . |
| Server Pribadi | Memungkinkan Anda untuk mengaktifkan [server pribadi](/docs/id-id/production/monetization/private-servers). |
| Produk Pengembang | Memungkinkan Anda membuat dan mengelola semua produk pengembang [untuk pengalaman Anda](/docs/id-id/production/monetization/developer-products). |
## [Keamanan](#keamanan)
Tab Keamanan berisi pengaturan yang terkait dengan komunikasi jaringan, penjualan, dan teleportasi.
Anda hanya harus mengaktifkan pengaturan berikut jika Anda percaya semua aset dari pengguna atau kelompok lain dalam pengalaman Anda, jika tidak, pengalaman Anda rentan terhadap risiko keamanan.
| Pengaturan | Deskripsi |
| --- | --- |
| Memungkinkan Permintaan HTTP | Memungkinkan server pengalaman untuk mengirim permintaan ke server jarak jauh melalui [HttpService](/docs/id-id/reference/engine/classes/HttpService) . |
| Rahasia | Memungkinkan pembuatan dan konfigurasi untuk sesi Studio lokal menggunakan .Untuk informasi lebih lanjut, lihat [Bekerja dengan rahasia](/docs/id-id/cloud-services/secrets#local-secrets). |
| Aktifkan Akses Studio ke Layanan API | Biarkan Studio mengakses layanan API. Pengaturan ini berguna untuk menguji implementasi layanan seperti [penyimpanan data](/docs/id-id/../cloud-services/data-stores). |
| Izinkan Penjualan Pihak Ketiga | Biarkan pemain membeli barang dari pihak ketiga.Ketika pengaturan ini dinonaktifkan, semua perintah pembelian dari aset yang Anda miliki akan terus berfungsi sementara perintah pembelian dari aset yang dipublikasikan oleh pengguna atau kelompok lain gagal. |
| Izinkan Teleportasi Pihak Ketiga | Biarkan pemain [berteleportasi](/docs/id-id/projects/teleport) ke pengalaman lain. |
## [Tempat](#tempat)
Tab Tempat berisi pengaturan khusus tempat.
| Pengaturan | Deskripsi |
| --- | --- |
| Buat | Memungkinkan Anda untuk membuat tempat baru dalam pengalaman Anda. |
| ⋯ | Membuka menu pop\-up dengan opsi untuk Konfigurasi Tempat (edit pengaturan khusus tempat seperti jumlah maksimum pemain), atau Histori Versi untuk melihat, download, dan membuka versi sebelumnya dari pengalaman. |
## [Lokalisasi](#lokalisasi)
Tab Lokalisasi berisi pengaturan bahasa yang terkait dengan [lokalisasi](/docs/id-id/production/localization) baik dalam pengalaman maupun di cloud.
| Pengaturan | Deskripsi |
| --- | --- |
| Bahasa Sumber | Memungkinkan Anda memilih bahasa yang biasa Anda gunakan untuk menciptakan pengalaman. |
| Penangkapan Teks Otomatis | Secara otomatis menangkap teks dari UI pengalaman saat pengguna mengakses pengalaman. |
| Gunakan Konten Terjemahan | Mengaktifkan konten terjemahan dalam pengalaman. |
| Terjemahan Otomatis | Bahasa yang ingin Anda aktifkan [terjemahan otomatis](/docs/id-id/production/localization/automatic-translations). |
## [Avatar](#avatar)
Tab Avatar termasuk pengaturan global untuk semua pengguna [avatar](/docs/id-id/characters) saat mereka berada dalam pengalaman.
| Pengaturan | Deskripsi |
| --- | --- |
| Prasekat | Atur opsi lebih rendah di tab untuk prasetel untuk Default , Skala Klasik , Klasik Penuh , Rthro , atau Pilihan Pemain . |
| Jenis Avatar | Atur jenis avatar default ke salah satu dari R6 , R15 , atau Pilihan Pemain . |
| Animasi | Atur animasi default ke Standar atau Pilihan Pemain . |
| Tabrakan | Tetapkan jenis kolisi ke kotak luar atau kotak dalam . |
| Skalanya | Untuk R15 avatar, pilihan untuk menyesuaikan ketiktubuh, tinggi, lebar, ukuran kepala, dan proporsi. |
| Bagian Tubuh | Memungkinkan Anda menggantikan bagian tubuh default pengguna ke ID khusus. |
| Pakaian | Memungkinkan Anda menggantikan ID pakaian klasik default pengguna ke ID khusus. |
## [Dunia](#dunia)
Tab Dunia termasuk pengaturan global untuk pengalaman, seperti gravitasi, perilaku lompatan karakter, dan kecepatan berjalan.
| Pengaturan | Deskripsi |
| --- | --- |
| Prasekat | Atur opsi lebih rendah di tab untuk prasetel untuk Klasik , Realistis , atau Tindakan . |
| Gravitasi | Tetapkan gravitasi dunia secara keseluruhan dalam stud per detik² (perhatikan meter per detik² yang setara dalam kurungan). |
| Lompat | Mengatur ketinggian lompatan humanoid di studs atau kekuatan lompatan di studs per detik.Perhatikan bagaimana menyesuaikan nilai ini mengubah jarak lompat maksimum dalam kaitannya dengan kecepatan berjalan. |
| Berjalan | Mengatur kecepatan berjalan manusia dalam stud per detik. Menyesuaikan nilai ini mengubah jarak lompatan maksimum dalam kaitannya dengan ketinggian lompatan atau kekuatan . |
| Lapangan | Menentukan sudut lereng maksimum yang dapat panjatoleh humanoid.Jika sudut dari lereng lebih besar dari nilai ini, humanoid akan meluncur ke bawah lereng. |
## [Lainnya](#lainnya)
Tab Lainnya termasuk pengaturan yang biasanya disediakan untuk situasi khusus, seperti skrip kolaboratif dan menutup semua server.
| Pengaturan | Deskripsi |
| --- | --- |
| Aktifkan Mode Kerangka Draf | Mengaktifkan pengeditan skrip asinkron, berdasarkan draft di sesi kolaboratif . |
| Matikan Semua Server | Mematikan semua server yang saat ini menjalankan pengalaman. |
| 55 |
https://create.roblox.com/docs/id-id/studio/shortcuts
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Jalan pintas studio
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/shortcuts).
Studio memiliki banyak pintasan default dan perintah kunci yang membuat pengembangan lebih cepat dan mudah.Anda dapat menyesuaikan setiap pintasan dan mengikat banyak tindakan tanpa default ke kunci apa pun melalui File → Lanjutkan ke Tingkat Lanjut → Sesuaikan Pintasan .
## [File dan publikasi](#file-dan-publikasi)
| Tindakan | Jendela | macOS | Deskripsi |
| --- | --- | --- | --- |
| Baru | CtrlN | ⌘N | Buat tempat baru. |
| Buka dari File... | CtrlO | ⌘O | Buka file lokal yang ada. |
| Buka dari Roblox... | CtrlShiftO | ⌘ShiftO | Buka pengalaman terbaru dari Roblox. |
| Menyimpan | CtrlS | ⌘S | Simpan tempat aktif ke lokasi yang saat ini terbuka di Studio. |
| Simpan ke File Sebagai... | CtrlShiftS | ⌘ShiftS | Simpan file lokal aktif dengan nama baru. |
| Publikasikan ke Roblox | AltP | ⌥P | Publikasikan tempat aktif ke Roblox. |
| Publikasikan ke Roblox Sebagai... | AltShiftP | ⌥ShiftP | Publikasikan tempat aktif ke Roblox sebagai versi baru. |
| Tempat Tutup | CtrlF4 | ⌘F4 | Tutup tempat terbuka. |
| Tutup Tab | CtrlW | ⌘W | Tutup tab aktif. |
| Buka Tab Sebelumnya | CtrlShiftT | ⌘ShiftT | Buka tab sebelumnya. |
| Keluar | CtrlQ | ⌘Q | Keluar dari aplikasi (Studio meminta untuk menyimpan dokumen). |
## [Kontrol kameranya](#kontrol-kameranya)
| Tindakan | Jendela | macOS | Deskripsi |
| --- | --- | --- | --- |
| Perbesar ke | F | F | Fokuskan kamera pada bagian/model yang dipilih. |
| Perbesar | Ctrl\= | ⌘\= | Perbesar kamera di dalam. |
| Perbesar Keluar | Ctrl\-O | ⌘\-O | Perbesar kamera keluar. |
| Sisi Kiri Pan | , | , | Putar kamera ke kiri. Jika bagian/model berfokus melalui pintasan F, putar kamera searah jarum jam di sekitar objek fokus. |
| Pan Kanan | . | . | Putar kamera ke kanan. Jika bagian/model berfokus melalui pintasan F, putar jam kamera searah jarum jam di sekitar objek fokus. |
| Miring Bawah | PageUp | PageUp | Miringkan kamera ke bawah. Jika bagian/model berfokus melalui pintasan F, miringkan kamera ke bawah tentang objek fokus. |
| Miring ke atas | PageDown | PageDown | Miringkan kamera ke atas. Jika bagian/model berfokus melalui pintasan F, miringkan kamera ke atas tentang objek fokus. |
## [Pilih dan edit](#pilih-dan-edit)
Jenderal
Objek 3D
Kontraksi
| Tindakan | Jendela | macOS | Deskripsi |
| --- | --- | --- | --- |
| Duplikasi | CtrlD | ⌘D | Duplikasi pilihan saat ini di tingkat yang sama dalam hierarki. |
| Menyalin | CtrlC | ⌘C | Salin pilihan saat ini ke clipboard. |
| Lempas | CtrlV⌃Y | ⌘V⌃Y | Sisipkan konten klipboard. |
| Lemparkan ke | CtrlShiftV | ⌘ShiftV | Tempelkan objek saat ini di clipboard sebagai anak\-anak dari objek yang dipilih. |
| Pangkas | CtrlX⌃K | ⌘X⌃K | Potong pilihan saat ini dan letakkan di bilah klip. |
| Menghapus | DeleteBackspace⌃D | DeleteBackspace⌃D | Hapus pilihan. |
| Pilih Semua | CtrlA | ⌘A | Pilih semua objek di ruang kerja atau semua baris di skrip. |
| Bersihkan Pilihan | Esc | Esc | Bersihkan pilihan saat ini. |
| Grup | CtrlG | ⌘G | Grupkan objek yang dipilih ke dalam baru [Model](/docs/id-id/reference/engine/classes/Model) . |
| Lepaskan Grup | CtrlU | ⌘U | Hapus kelompok pilihan [Model](/docs/id-id/reference/engine/classes/Model) ke objek individu. |
| Membatalkan | CtrlZ | ⌘Z | Membatalkan actionterakhir. |
| Membatalkan | CtrlShiftZ | ⌘ShiftZ | Membatalkan actionyang sebelumnya tidak dilakukan. |
## [Kontrol kendali](#kontrol-kendali)
| Tindakan | Jendela | macOS | Deskripsi |
| --- | --- | --- | --- |
| Tampilkan Grid | AltG | ⌥G | Tampilkan atau sembunyikan grid 3D di Y pesawat. |
| Penjelajah | AltX | ⌥X | Tampilkan atau sembunyikan jendela [Explorer](/docs/id-id/studio/explorer). |
| Filter Penjelajah | CtrlShiftX | ⌘ShiftX | Lompat ke bidang input filter jendela [Explorer](/docs/id-id/studio/explorer). |
| Filter Properti | CtrlShiftP | ⌘ShiftP | Lompat ke bidang masuk filter jendela [Properti](/docs/id-id/studio/properties). |
| Sisipkan Objek | CtrlI | ⌘I | Buka popup Sisipkan Objek untuk sisipan cepat objek. Setelah dibuka, popup dapat ditutup dengan Esc . |
| Buka Cepat | CtrlP | ⌘P | Tampilkan jendela Buka Cepat untuk segera menemukan instance di hierarki. |
| Tindakan Buka Cepat | AltCtrlP | ⌥⌘P | Tampilkan jendela Tindakan Buka Cepat untuk segera menemukan actionStudio. |
| Pengaturan Studio | AltS | ⌥S | Buka jendela pengaturan Studio. |
| Layar Penuh | F11AltF11 | F11⌥F11 | Toggle antara layar penuh dan tampilan jendela. |
| Catatan Video | F12 | | Catat video; tidak berfungsi di Mac. |
| Fokus pada Bilah Perintah | Ctrl9 | ⌘9 | Atur fokus keyboard ke Bilah Perintah yang digunakan untuk mengeksekusi kode Luau di luar skrip. |
## [Pengujian dan diagnostik](#pengujian-dan-diagnostik)
| Tindakan | Jendela | macOS | Deskripsi |
| --- | --- | --- | --- |
| Mainkan / Jeda / Lanjutkan | F5 | F5 | Mulai simulasi pengalaman di Studio. Tekan lagi untuk menghentikan simulasi yang sedang berjalan atau melanjutkan simulasi yang terhenti. |
| Berhenti | ShiftF5 | ShiftF5 | Hentikan simulasi saat ini. |
| Jalankan | F8 | F8 | Mulai simulasi pengalaman tanpa avatar Anda dari posisi kamera saat ini. |
| Mulai | F7 | F7 | Simulasikan lingkungan Roblox dengan memulai beberapa sesi baru Studio. |
| Simpan dan Muat Ulang Plugin di Debugger | CtrlShiftL | ⌘ShiftL | Simpan semua plugin di debugger kembali ke disk, hentikan eksekusi plugin tersebut, dan muat ulang dari disk. |
| Status | CtrlShiftF1 | ⌘ShiftF1 | Tampilkan statistik pengalaman terperinci. |
| Rendahkan | CtrlShiftF2 | ⌘ShiftF2 | Tampilkan grafik dan data kinerja terperinci. |
| Jaringan | CtrlShiftF3 | ⌘ShiftF3 | Tampilkan statistik jaringan terperinci. Setelah dibuka, tekan Shift1 siklus melalui panel data tambahan. |
| Fisika | CtrlShiftF4 | ⌘ShiftF4 | Tampilkan data fisika terperinci. |
| Singkatan | CtrlShiftF5 | ⌘ShiftF5 | Tampilkan ringkasan data statistik. |
## [Editor Naskah](#editor-naskah)
File \& Penampilan
Editasi Dasar
Kursor Multi
| Perintah | Jendela | macOS |
| --- | --- | --- |
| Tutup Skrip | CtrlW | ⌘W |
| Buka Kembali Skrip Terakhir yang Ditutup | CtrlShiftT | ⌘ShiftT |
| Buka Cepat | CtrlP | ⌘P |
| Tampilkan Skrip di Explorer | CtrlAltK | ⌘⌥K |
| Perbesar | Ctrl\= | ⌘\= |
| Perbesar Keluar | Ctrl\- | ⌘\- |
| Setel Ulang Zoom Skrip | Ctrl0 | ⌘0 |
| 56 |
https://create.roblox.com/docs/id-id/studio/plugins
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Plugin
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/plugins).
Sebuah plugin adalah ekstensi yang menambahkan fitur atau fungsi tambahan ke Studio.Anda dapat [instal](/docs/id-id/production/creator-store#find-assets) plugin yang dibuat komunitas dari Toko Toko Kreator, atau Anda dapat [buat](#create-new-plugins) dan [publikasikan](#upload-distribute-and-monetize-plugins) plugin Anda sendiri ke [Toolbox](/docs/id-id/projects/assets/toolbox) untuk digunakan di seluruh pengalaman Anda.
Jika Anda memilih untuk juga mendistribusikan plugin Anda ke Toko Pencipta, Anda dapat menawarkannya secara gratis atau menjualnya seharga Dolar Amerika Serikat (harga minimum adalah $4,99\).Roblox menawarkan bagian pendapatan teratas untuk penjualan ini, karena hanya pajak dan biaya pemrosesan pembayaran yang dikurangi.Untuk informasi lebih lanjut tentang menjual plugin, lihat [Menjual di Toko Pencipta](/docs/id-id/production/sell-on-creator-store).
## [Buat plugin baru](#buat-plugin-baru)
Anda dapat membuat plugin sendiri untuk meningkatkan alur kerja Anda di Studio.Contoh kode berikut adalah plugin bernama EmptyScriptAdder yang menyisipkan skrip kosong sebagai anak dari objek atau di [ServerScriptService](/docs/id-id/reference/engine/classes/ServerScriptService) .Bagian berikut menjelaskan bagian utama untuk membuat plugin ini.
Untuk memulai, Anda harus mengaktifkan Debugging Plugin Diaktifkan di bagian Studio dari pengaturan Studio.Ini akan mengekspos [PluginDebugService](/docs/id-id/reference/engine/classes/PluginDebugService) di Studio yang memberikan debugging waktu nyata untuk kode plugin Anda dan memudahkan untuk memuat ulang dan menyimpan plugin Anda.
```
Plugin Pengisi Skrip Kosong
---
```
local ChangeHistoryService = game:GetService("ChangeHistoryService")
local Selection = game:GetService("Selection")
-- Buat bagian bilah alat baru berjudul "Alat Skrip Kustom"
local toolbar = plugin:CreateToolbar("Custom Script Tools")
-- Tambahkan tombol bilah alat bernama "Buat Skrip Kosong"
local newScriptButton = toolbar:CreateButton("Create Empty Script", "Create an empty script", "rbxassetid://14978048121")
-- Buat tombol dapat diklik bahkan jika viewport 3D tersembunyi
newScriptButton.ClickableWhenViewportHidden = true
local function onNewScriptButtonClicked()
local selectedObjects = Selection:Get()
local parent = game:GetService("ServerScriptService")
if #selectedObjects > 0 then
parent = selectedObjects[1]
end
local newScript = Instance.new("Script")
newScript.Source = ""
newScript.Parent = parent
ChangeHistoryService:SetWaypoint("Added new empty script")
end
newScriptButton.Click:Connect(onNewScriptButtonClicked)
```
```
### [Simpan skrip plugin](#simpan-skrip-plugin)
Plugin dimulai dari skrip.Untuk membuat plugin, buat [Script](/docs/id-id/reference/engine/classes/Script) dan simpan sebagai plugin menggunakan [Explorer](/docs/id-id/studio/explorer).Sebagai contoh, untuk membuat Plugin EmptyScriptAdder :
1. Sisipkan baru [Script](/docs/id-id/reference/engine/classes/Script) di dalam [ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage) dan ganti namanya menjadi EmptyScriptAdder .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/plugins/Plugin-Empty-Script-Adder.png' alt='' title='' width='320' height='' />
2. Salin dan tempel kode EmptyScriptAdder Plugin ke dalam skrip baru.
3. Di jendela Explorer , klik kanan pada skrip dan pilih Simpan sebagai Plugin Lokal .
4. Di jendela popup, klik Simpan untuk menyisipkan skrip plugin ke dalam folder lokal Plugin dari instalasi Studio.
5. Plugin harus muncul di [PluginDebugService](/docs/id-id/reference/engine/classes/PluginDebugService) dan mulai berjalan.
Pastikan untuk menghapus skrip asli di [ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage) dan bekerja dari plugin di dalam [PluginDebugService](/docs/id-id/reference/engine/classes/PluginDebugService) , jika tidak, Anda mungkin akhirnya menerapkan perubahan pada skrip yang salah.
### [Muat ulang dan simpan perubahan](#muat-ulang-dan-simpan-perubahan)
Dengan [Plugin](/docs/id-id/reference/engine/classes/Plugin) di dalam [PluginDebugService](/docs/id-id/reference/engine/classes/PluginDebugService) , Anda dapat dengan mudah memperbarui plugin dengan mengklik kanan dan kemudian memilih Simpan dan Muat Ulang Plugin dari menu konteks.Jika Anda hanya ingin memuat ulang plugin, misalnya untuk melalui bagian kode menggunakan titik istirahat tanpa menyimpan plugin, Anda dapat secara alternatif memilih Memuat Ulang Plugin .
### [Tambahkan tombol bilah alat](#tambahkan-tombol-bilah-alat)
Untuk menambahkan tombol untuk plugin Anda ke tab Plugins dari bilah alat Studio, gunakan metode [Plugin:CreateToolbar()](/docs/id-id/reference/engine/classes/Plugin#CreateToolbar) dan [PluginToolbar:CreateButton()](/docs/id-id/reference/engine/classes/PluginToolbar#CreateButton).Dalam kode untuk EmptyScriptAdder , baris 5 membuat bagian baru di bilah alat bernama Alat Skrip Kustom dan baris 8 membuat tombol bernama Buat Skrip Kosong .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/plugins/Plugin-Toolbar-Button.png' alt='New plugin button added to toolbar in Studio' title='' width='800' height='' />
### [Jalankan kode saat klik](#jalankan-kode-saat-klik)
Untuk membuat plugin mengeksekusi kode saat pengguna mengklik tombol bilah alat, hubungkan fungsi ke acara tombol [PluginToolbarButton.Click](/docs/id-id/reference/engine/classes/PluginToolbarButton#Click) pengguna.Dalam kode untuk EmptyScriptAdder , fungsi penghubung adalah onNewScriptButtonClicked().
### [Periksa pemilihan pengguna](#periksa-pemilihan-pengguna)
Untuk memodifikasi perilaku plugin berdasarkan apa yang telah dipilih pengguna, gunakan layanan [Selection](/docs/id-id/reference/engine/classes/Selection).Fungsi onNewScriptButtonClicked() memeriksa apakah pengguna memiliki sesuatu yang dipilih dan membuat skrip baru sebagai anaknya bukan di dalam [ServerScriptService](/docs/id-id/reference/engine/classes/ServerScriptService) .Jika pengguna tidak memiliki apa pun yang dipilih, itu membuat skrip baru di [ServerScriptService](/docs/id-id/reference/engine/classes/ServerScriptService) .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/plugins/Plugin-Inserted-Script.png' alt='' title='' width='320' height='' />
### [Dukungan membatalkan dan memulai ulang](#dukungan-membatalkan-dan-memulai-ulang)
Gunakan [ChangeHistoryService](/docs/id-id/reference/engine/classes/ChangeHistoryService) untuk memungkinkan pengguna membatalkan dan mengulangi perubahan yang dilakukan oleh plugin dalam pengalaman.Di skrip Anda, atur plugin untuk memanggil [ChangeHistoryService:TryBeginRecording()](/docs/id-id/reference/engine/classes/ChangeHistoryService#TryBeginRecording) dan menyimpan identifikator yang ditugaskan ke panggilan API sebelum melakukan perubahan.Kemudian atur plugin untuk memanggil [ChangeHistoryService:FinishRecording()](/docs/id-id/reference/engine/classes/ChangeHistoryService#FinishRecording) setelah melakukan perubahan, sehingga dapat menangkap semua perubahan yang dilakukan selama sesi perekaman untuk dibatalkan dan diulangi.
Contoh kode berikut membuat plugin contoh yang dapat menerapkan material neon ke bagian yang dipilih.Ini menggunakan [ChangeHistoryService](/docs/id-id/reference/engine/classes/ChangeHistoryService) untuk merekam dan mengelola perubahan yang dilakukan oleh plugin:
```
Contoh Plugin Bahan dengan Rekaman untuk Membatalkan dan Memperbaiki
---
```
local ChangeHistoryService = game:GetService("ChangeHistoryService")
local Selection = game:GetService("Selection")
-- Buat plugin contoh
local toolbar = plugin:CreateToolbar("Example Plugin")
local button = toolbar:CreateButton("Neon it up", "", "")
-- Hubungkan fungsi ke acara klik
button.Click:Connect(function()
local parts = {}
for _, part in Selection:Get() do
if part:IsA("BasePart") then
parts[#parts + 1] = part
end
end
if #parts < 1 then
-- Tidak ada yang perlu dilakukan.
return
end
-- Coba mulai rekaman dengan identifikasi spesifik
local recording = ChangeHistoryService:TryBeginRecording("Set selection to neon")
-- Periksa apakah perekaman berhasil dimulai
if not recording then
-- Tangani kesalahan di sini. Ini menunjukkan bahwa plugin Anda memulai sebelumnya
-- merekam dan tidak pernah menyelesaikannya. Anda mungkin hanya memiliki satu rekaman
-- per plugin aktif pada satu waktu.
return
end
-- Berulang melalui bagian yang dipilih
for _, part in parts do
part.Material = Enum.Material.Neon -- Tetapkan material bagian ke Neon
end
-- Selesaikan perekaman, mengkomitkan perubahan ke histori
ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Commit)
end)
```
```
## [Upload, distribusikan, dan monetarisasi plugin](#upload-distribusikan-dan-monetarisasi-plugin)
Seperti dengan [model](/docs/id-id/parts/models) , [meshes](/docs/id-id/parts/meshes) , [gambar](/docs/id-id/parts/textures-decals) , dan [animasi](/docs/id-id/animation/editor#creating-an-animation) , Anda dapat mendistribusikan plugin ke Roblox untuk membuatnya mudah digunakan kembali dari [Toolbox](/docs/id-id/projects/assets/toolbox) .Anda dapat memilih untuk menyediakannya secara publik kepada semua pencipta lain di [Toko Pencipta](/docs/id-id/production/creator-store), atau untuk mendistribusikannya secara pribadi untuk penggunaan Anda sendiri.Jika Anda memilih untuk mendistribusikan plugin Anda secara publik, Anda dapat menetapkan harga di mana untuk menjualnya kepada pencipta lain.
Satu\-satunya cara untuk mendistribusikan dan menetapkan harga untuk plugin adalah melalui Dasbor Kreator.Anda selalu dapat mengunggah plugin menggunakan proses ini dan memonetisasinya nanti dari dasbor.Untuk instruksi tentang proses ini, lihat [Mendistribusikan Aset](/docs/id-id/production/creator-store#through-creator-dashboard).
Untuk mendistribusikan plugin:
1. Di jendela Explorer , klik kanan skrip plugin, lalu pilih Terbitkan sebagai Plugin dari menu konteks.
2. (Opsi) Di sudut kiri atas jendela konfigurasi aset, klik gambar untuk mengunggah gambar 512×512\.
3. Isi bidang berikut:
* Nama : Judul untuk plugin Anda.
* Deskripsi : Deskripsi yang menjelaskan apa yang pengguna potensial harapkan plugin lakukan.
* Pencipta : Pencipta yang ingin Anda atribusikan sebagai pencipta plugin.
4. Klik tombol Kirim .Plugin Anda sekarang tersedia untuk Anda di tab Inventaris dan Kreasi dari [Toolbox](/docs/id-id/projects/assets/toolbox).
5. Klik tautan ke Dashboard Pencipta untuk [mengkonfigurasi distribusi](/docs/id-id/production/creator-store#through-creator-dashboard).
Untuk mendistribusikan atau memonetarisasi plugin yang sebelumnya Anda unggah secara publik, gunakan bagian [Kreasi dari Dashboard Pencipta](https://create.roblox.com/dashboard/creations?activeTab=Model).Untuk informasi lebih lanjut, lihat [Mendistribusikan Aset](/docs/id-id/production/creator-store).
| 57 |
https://create.roblox.com/docs/id-id/studio/build-studio-widgets
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Membangun widget Studio
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/studio/build-studio-widgets).
Studio memberi Anda kekuatan untuk membuat widget khusus dan menggunakannya sebagai alat dan ekstensi Studio .Widget ini berperilaku sebagai jendela/panel khusus di Studio, dan Anda dapat mendocknya di dalam antarmuka Anda atau membiarkannya mengambang sebagai jendela terpisah.
## [Buat UI widget](#buat-ui-widget)
Semua widget Studio dimulai sebagai objek [DockWidgetPluginGui](/docs/id-id/reference/engine/classes/DockWidgetPluginGui) yang dapat Anda isi dengan [GuiObjects](/docs/id-id/reference/engine/classes/GuiObject) , seperti label teks dan tombol.Untuk membuat GUI widget kosong, panggil fungsi [CreateDockWidgetPluginGui()](/docs/id-id/reference/engine/classes/Plugin#CreateDockWidgetPluginGui), dengan menyertakan ID dan objek [DockWidgetPluginGuiInfo](/docs/id-id/reference/engine/datatypes/DockWidgetPluginGuiInfo).
Perhatikan konstruktor mengharapkan parameternya dalam urutan tertentu sebagai berikut:
| \# | Propinsi | Jenis | Deskripsi |
| --- | --- | --- | --- |
| 1 | [Enum.InitialDockState](/docs/id-id/reference/engine/enums/InitialDockState) | Enumerasi | Salah satu dari [Enum.InitialDockState](/docs/id-id/reference/engine/enums/InitialDockState) enumerasi. |
| 2 | InitialEnabled | Boolean | Status awal yang diaktifkan (terlihat) dari widget GUI. |
| 3 | InitialEnabledShouldOverrideRestore | Boolean | Jika benar, nilai InitialEnabled menggantikan status aktif yang sebelumnya disimpan. |
| 4 | FloatingXSize | Angka bulat | Lebar awal GUI saat InitialDockState diatur ke [Enum.InitialDockState.Float](/docs/id-id/reference/engine/enums/InitialDockState#Float). |
| 5 | FloatingYSize | Angka bulat | Tinggi awal GUI saat InitialDockState diatur ke [Enum.InitialDockState.Float](/docs/id-id/reference/engine/enums/InitialDockState#Float). |
| 6 | MinWidth | Angka bulat | Lebar minimum GUI, dengan beberapa variasi khusus platform. |
| 7 | MinHeight | Angka bulat | Ketinggian minimum dari GUI, dengan beberapa variasi khusus platform. |
```
---
```
-- Buat objek "DockWidgetPluginGuiInfo" baru
local widgetInfo = DockWidgetPluginGuiInfo.new(
Enum.InitialDockState.Float, -- Widget akan diinisialisasi di panel mengambang
true, -- Widget akan diaktifkan awalnya
false, -- Jangan membatalkan status yang diaktifkan sebelumnya
200, -- Lebar default dari jendela mengambang
300, -- Ketinggian default dari jendela mengambang
150, -- Lebar minimum dari jendela mengambang
150 -- Ketinggian minimum dari jendela mengambang
)
-- Buat GUI widget baru
local testWidget = plugin:CreateDockWidgetPluginGui("TestWidget", widgetInfo)
testWidget.Title = "Test Widget" -- Optional widget title
```
```
Anda tidak dapat menggunakan fungsi [CreateDockWidgetPluginGui()](/docs/id-id/reference/engine/classes/Plugin#CreateDockWidgetPluginGui) di skrip permainan. Anda hanya dapat memanggilnya dari bilah perintah atau skrip [plugin](/docs/id-id/studio/plugins).
### [Sesuaikan UI widget kustom](#sesuaikan-ui-widget-kustom)
Setelah Anda membuat widget, Anda dapat menyesuaikan antarmuka pengguna dengan [GuiObjects](/docs/id-id/reference/engine/classes/GuiObject) seperti informatif [TextLabels](/docs/id-id/reference/engine/classes/TextLabel) atau interaktif [ImageButtons](/docs/id-id/reference/engine/classes/ImageButton) .Sebagai contoh, kode berikut menambahkan kode dasar [TextButton](/docs/id-id/reference/engine/classes/TextButton) ke jendela GUI:
```
---
```
-- Buat GUI widget baru
local testWidget = plugin:CreateDockWidgetPluginGui("TestWidget", widgetInfo)
testWidget.Title = "Test Widget" -- Judul widget opsional
local testButton = Instance.new("TextButton")
testButton.BorderSizePixel = 0
testButton.TextSize = 20
testButton.TextColor3 = Color3.new(1,0.2,0.4)
testButton.AnchorPoint = Vector2.new(0.5,0.5)
testButton.Size = UDim2.new(1,0,1,0)
testButton.Position = UDim2.new(0.5,0,0.5,0)
testButton.SizeConstraint = Enum.SizeConstraint.RelativeYY
testButton.Text = "Click Me"
testButton.Parent = testWidget
```
```
Perhatikan bahwa Anda harus membatalkan tombol ke widget dengan cara yang sama seperti Anda harus membatalkan layar mana pun dalam pengalaman [GuiObject](/docs/id-id/reference/engine/classes/GuiObject) ke [ScreenGui](/docs/id-id/reference/engine/classes/ScreenGui).
Untuk membantu Anda membuat widget Studio konsisten dan efektif, Roblox menyediakan [repo GitHub](https://github.com/Roblox/StudioWidgets) yang berisi elemen GUI dengan tampilan dan nuansa "Studio" standar.Ini termasuk kotak centang, tombol radio, dan bidang input yang memiliki gaya Studio, dan mereka semua mendukung tema gelap.
### [Ubah tema warna Studio](#ubah-tema-warna-studio)
Widget Studio yang efektif idealnya cocok dengan pengaturan tema Studio dan disesuaikan secara dinamis saat tema berubah.Sebagai kejadian, jika seorang pengembang menggunakan tema gelap, warna latar belakang widget, gambar, dan label teks harus terlihat bagus di samping warna tema asli Studio.
Penyambungan kode berikut menggunakan fungsi syncGuiColors() yang awalnya dipanggil bersama dengan tabel objek GUI untuk disinkronkanDi dalam fungsi, loop fungsi terkait setColors() melalui objek dan sinkronisasi aspek khusus dari mereka menggunakan [GetColor()](/docs/id-id/reference/engine/classes/StudioTheme#GetColor) dengan [Enum.StudioStyleGuideColor](/docs/id-id/reference/engine/enums/StudioStyleGuideColor) enum.Fungsi ini setColors() berjalan segera untuk menyinkronkan tema Studio, lalu terhubung ke acara [ThemeChanged](/docs/id-id/reference/engine/classes/Studio#ThemeChanged) untuk mendeteksi perubahan tema di masa depan.
```
---
```
testButton.Parent = testWidget
local function syncGuiColors(objects)
local function setColors()
for _, guiObject in objects do
-- Sinkronkan warna latar belakang
guiObject.BackgroundColor3 = settings().Studio.Theme:GetColor(Enum.StudioStyleGuideColor.MainBackground)
-- Sinkronkan warna teks
guiObject.TextColor3 = settings().Studio.Theme:GetColor(Enum.StudioStyleGuideColor.MainText)
end
end
-- Jalankan fungsi 'setColors()' untuk awalnya menyinkronkan warna
setColors()
-- Hubungkan acara 'ThemeChanged' ke fungsi 'setColors()'
settings().Studio.ThemeChanged:Connect(setColors)
end
-- Jalankan fungsi 'syncGuiColors()' untuk menyinkronkan warna objek yang disediakan
syncGuiColors({testButton})
```
```
### [Sesuaikan kurator mouse](#sesuaikan-kurator-mouse)
Untuk meningkatkan interaksi yang diharapkan dengan elemen widget, Anda dapat mengatur kursor sistem khusus ke acara GUI, seperti dan .Kode berikut menunjukkan cara menghubungkan fungsi ke [MouseEnter](/docs/id-id/reference/engine/classes/GuiObject#MouseEnter) dan [MouseLeave](/docs/id-id/reference/engine/classes/GuiObject#MouseLeave) peristiwa testButton untuk mengubah kursor mouse:
```
---
```
local function setCursor(cursorAsset)
plugin:GetMouse().Icon = cursorAsset
end
testButton.MouseEnter:Connect(function()
setCursor("rbxasset://SystemCursors/PointingHand")
end)
testButton.MouseLeave:Connect(function()
setCursor("")
end)
```
```
Referensikan tabel berikut untuk daftar kursor mouse dan kasus penggunaan potensial mereka:
| Ikon Kursor Mouse | Aset | Gunakan Kasus |
| --- | --- | --- |
| | rbxasset://SystemCursors/Arrow | Klik dan seleksi default. |
| | rbxasset://SystemCursors/PointingHand | Melayang di atas tautan aktif/tombol aktif. |
| | rbxasset://SystemCursors/OpenHand | Melayang di atas item yang dapat diseret. |
| | rbxasset://SystemCursors/ClosedHand | Menyeret item. |
| | rbxasset://SystemCursors/IBeam | Menggantung di bidang teks. |
| | rbxasset://SystemCursors/SizeNS | Melayang di atas pegangan resize vertikal. |
| | rbxasset://SystemCursors/SizeEW | Menggantung di atas pegangan resize horizontal. |
| | rbxasset://SystemCursors/SizeNESW | Melayang di atas pegangan resize sudut. |
| | rbxasset://SystemCursors/SizeNWSE | Melayang di atas pegangan resize sudut. |
| | rbxasset://SystemCursors/SizeAll | Menggantung di atas pegangan resize multi\-arah. |
| | rbxasset://SystemCursors/SplitNS | Melayang di atas pegangan "bagi" vertikal. |
| | rbxasset://SystemCursors/SplitEW | Melayang di atas pegangan "bagi" horizontal. |
| | rbxasset://SystemCursors/Forbidden | Melayang di atas item terkunci/dilarang. |
| | rbxasset://SystemCursors/Wait | Menunjukkan bahwa tindakan sedang berlangsung. |
| | rbxasset://SystemCursors/Busy | Mengindikasikan sistem sibuk. |
| | rbxasset://SystemCursors/Cross | Melayang di atas area seleksi titik tertentu. |
Perhatikan bahwa tampilan kursor ini hanya sebuah aproksimasi \- kursor aktual cocok dengan kursor sistem operasi default Anda.
## [Kumpulkan input pengguna](#kumpulkan-input-pengguna)
Elemen UI seperti [TextBox](/docs/id-id/reference/engine/classes/TextBox) dan [TextButton](/docs/id-id/reference/engine/classes/TextButton) bekerja secara normal di widget Studio, dan Anda dapat membangun antarmuka seperti yang biasanya Anda lakukan di Roblox.Namun, [UserInputService](/docs/id-id/reference/engine/classes/UserInputService) dan [ContextActionService](/docs/id-id/reference/engine/classes/ContextActionService) tidak berfungsi karena layanan ini mengharapkan jendela permainan utama berada dalam fokus.
Satu solusi sementara untuk acara input umum adalah membuat transparan [Frame](/docs/id-id/reference/engine/classes/Frame) dan menumpangkannya di seluruh layar.Contoh kode berikut membuat frame, dan ketika pengguna mengklik frame, acara [GuiObject.InputBegan](/docs/id-id/reference/engine/classes/GuiObject#InputBegan) menangkap input keyboard pada frame sampai pengguna mengklik jauh:
```
---
```
local frame = Instance.new("Frame")
frame.BackgroundTransparency = 1 -- Sembunyikan frame
frame.Size = UDim2.new(1, 0, 1, 0) -- Tutup layar
frame.Position = UDim2.new(0, 0, 0, 0)
frame.Parent = testWidget
local function onInputBegan(inputObject)
-- Proses objek input di sini, misalnya mendeteksi tekanan tombol
end
frame.InputBegan:Connect(onInputBegan)
```
```
## [Interaksi seret dan lepaskan](#interaksi-seret-dan-lepaskan)
Menggunakan interaksi seret dan lepaskan untuk widget Anda adalah cara sederhana untuk meningkatkan aliran data.Untuk membuat interaksi ini, Anda harus mendefinisikan elemen untuk diseret, memulai seretan, membuat target jatuh, dan memproses actionjatuh.
### [Buat sumber seret](#buat-sumber-seret)
Anda dapat memulai tindakan seret dengan memanggil [Plugin:StartDrag()](/docs/id-id/reference/engine/classes/Plugin#StartDrag) ketika pengguna menekan tombol mouse pada beberapa elemen UI, biasanya [TextButton](/docs/id-id/reference/engine/classes/TextButton) atau [ImageButton](/docs/id-id/reference/engine/classes/ImageButton) di dalam widget.Contoh kode berikut membuat widget jendela tunggal dengan tombol teks di dalamnya.
```
---
```
-- Buat widget pertama
local widgetInfo = DockWidgetPluginGuiInfo.new(Enum.InitialDockState.Float, true, true, 300, 200)
local dragSourceWidget = plugin:CreateDockWidgetPluginGui("Drag Source", widgetInfo)
dragSourceWidget.Title = "Drag Source"
-- Buat Tombol Teks yang akan memulai seretan
local dragButton = Instance.new("TextButton")
dragButton.Size = UDim2.new(1, 0, 1, 0)
dragButton.Text = "Drag me!"
dragButton.Parent = dragSourceWidget
```
```
### [Mulai seret](#mulai-seret)
Ketika pengguna mengklik pada [TextButton](/docs/id-id/reference/engine/classes/TextButton), Anda dapat memulai seret melalui peristiwa [MouseButton1Down()](/docs/id-id/reference/engine/classes/GuiButton#MouseButton1Down) yang dinyalakan saat pengguna menekan tombol mouse.
Dalam fungsi terhubung, tentukan data untuk ditarik.Tipe data harus dicerminkan dalam unit, konten seret harus dicerminkan dalam unit, dan pengirim harus menggambarkan dirinya sendiri dalam unit.Lihat halaman [Plugin:StartDrag()](/docs/id-id/reference/engine/classes/Plugin#StartDrag) untuk lebih banyak rincian.
```
---
```
local function onButton1Down()
local dragInfo = {
Data = "Hello, world", -- Data yang diseret
MimeType = "text/plain", -- Menggambarkan jenis MIME data
Sender = "SomeDragSource", -- Menjelaskan dari mana data berasal
MouseIcon = "", -- Konten gambar untuk digunakan untuk kursor
DragIcon = "", -- Konten gambar untuk disajikan di bawah kursor selama seret
HotSpot = Vector2.zero -- Di mana di DragIcon untuk menyentralkan kursor
}
plugin:StartDrag(dragInfo)
end
dragButton.MouseButton1Down:Connect(onButton1Down)
```
```
### [Buat target jatuh](#buat-target-jatuh)
Peristiwa [PluginGui.PluginDragDropped](/docs/id-id/reference/engine/classes/PluginGui#PluginDragDropped) terjadi ketika pengguna melepaskan mouse mereka di jendela selama seretan.Ketika ini terjadi, Anda perlu mendefinisikan target jatuh seperti widget kedua dengan [TextLabel](/docs/id-id/reference/engine/classes/TextLabel) untuk mendeteksi jatuh.
```
---
```
local dragTargetWidget = plugin:CreateDockWidgetPluginGui("Drop Target", widgetInfo)
dragTargetWidget.Title = "Drop Target"
-- Label Teks ini akan menampilkan apa yang dijatuhkan
local textLabel = Instance.new("TextLabel")
textLabel.Size = UDim2.new(1, 0, 1, 0)
textLabel.Text = "Drop here..."
textLabel.Parent = dragTargetWidget
```
```
### [Proses tindakan action](#proses-tindakan-action)
Setelah membuat target jatuh, hubungkan acara [PluginGui.PluginDragDropped](/docs/id-id/reference/engine/classes/PluginGui#PluginDragDropped) pada widget target jatuh:
```
---
```
local function onDragDrop(dragData)
print("PluginDragDropped")
if dragData.MimeType == "text/plain" then
textLabel.Text = dragData.Data
else
textLabel.Text = dragData.MimeType
end
end
dragTargetWidget.PluginDragDropped:Connect(onDragDrop)
```
```
Sementara seretan masih dalam progres, ketiga peristiwa ini terbakar saat pengguna memindahkan mouse mereka di atas widget:
* [PluginDragEntered](/docs/id-id/reference/engine/classes/PluginGui#PluginDragEntered) – menyala saat pengguna menggerakkan mouse di atas jendela
* [PluginDragMoved](/docs/id-id/reference/engine/classes/PluginGui#PluginDragMoved) – terbakar berulang kali saat pengguna menggerakkan mouse mereka di atas jendela. Ini berguna untuk menampilkan pesan "Drop here!"
* [PluginDragLeft](/docs/id-id/reference/engine/classes/PluginGui#PluginDragLeft) – terbakar saat kursor pengguna meninggalkan jendela. Ini berguna untuk menyembunyikan pesan "Drop here!"
| 58 |
https://create.roblox.com/docs/id-id/creator-programs
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Program pencipta
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs).
Roblox menawarkan berbagai program untuk pencipta di platform untuk memberikan dukungan dan eksposur tambahan.Di bawah ini, kami berbagi program yang tersedia secara publik untuk pencipta.Periksa mereka dan lihat apa yang Anda memenuhi syarat untuk.
#### Direktori Pengembang Merek dan Program Mitra Roblox
Status: Open
Mempromosikan pengembang dengan latar belakang kuat dalam bermitra dengan merek[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/brand-developer-directory)
#### Program Umpan Balik Komunitas
Status: Open
Mengumpulkan kelompok aktif dan pencipta tepercaya yang beragam untuk bekerja erat dengan staf Roblox[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/feedback)
#### Program Pilot Afiliasi Pencipta
Status: Open
Hadiah pencipta untuk membawa pengguna baru ke Roblox[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/creator-affiliate)
#### Peristiwa Pencipta
Status: Open
Menyelenggarakan acara virtual untuk mengajar orang lain di komunitas pencipta Roblox[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/creator-events)
#### Dana Pencipta
Status: Closed
Pendanaan untuk pencipta yang ingin membangun generasi berikutnya dari pengalaman Roblox[Pelajari Lebih Lanjut](/docs/id-id/creator-fund)
#### Sorotan Pencipta
Status: Open
Artikel DevForum yang merayakan hal\-hal mengagumkan yang dicapai oleh pencipta kami[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/spotlights)
#### Penghargaan Pengembang
Status: Open
Program yang didorong data dirancang untuk menghadiahi pengembang karena mencapai tonggak penting dalam pengalaman mereka[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/developer-awards)
#### Menginspirasi
Status: Open
Inspirasi adalah acara online global tahunan di mana pencipta berkumpul untuk bertukar ide dan belajar dari satu sama lain.[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/inspire)
#### Pelajari \& Jelajahi Urutan
Status: Open
Menyoroti pengalaman yang memungkinkan pengguna mempelajari topik pendidikan dengan cara yang menarik[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/learn-explore-sort)
#### Integrasi Merek Terkelola
Status: Open
Program undangan hanya yang menargetkan merek yang ingin terintegrasi ke dalam pengalaman Roblox populer[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/managed-brand-integrations)
#### Program Penerjemah Terkenal
Status: Open
Penerjemah komunitas terampil yang menawarkan layanan kepada pencipta Roblox lainnya[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/notable-translators)
#### Konferensi Pengembang Roblox
Status: Open
RDC adalah acara hibrida undangan saja yang membawa bersama pengembang Roblox, merek, dan kreator dari seluruh dunia.[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/rdc)
#### Penghargaan Inovasi Roblox
Status: Open
Setiap tahun, RIAs diberikan kepada pencipta paling inovatif, bintang video, dan pengalaman.[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/innovation-awards)
#### Panel Penelitian Roblox
Status: Open
Program eksklusif untuk orang berbagi pendapat mereka untuk membantu meningkatkan Roblox[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/research-panel)
#### Pilihan Hari Ini di Rumah
Status: Open
Kurasi harian dari update menarik, pengalaman baru dan menonjol, acara, dan acara budaya untuk memberikan pengguna konten segar[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/todays-picks-home)
#### Pilihan Hari Ini di Pasar
Status: Open
Kurasi harian item Pasar untuk membantu pengguna membawa diri unik mereka ke Roblox[Pelajari Lebih Lanjut](/docs/id-id/creator-programs/todays-picks-marketplace)
| 59 |
https://create.roblox.com/docs/id-id/creator-programs/brand-developer-directory
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Direktori Pengembang Merek dan Program Mitra Roblox
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/brand-developer-directory).
Direktori Pengembang Merek mempromosikan pengembang dengan sejarah menciptakan pengalaman menarik di platform dan bermitra dengan merek.Direktori ini akan menawarkan lebih banyak visibilitas bagi Anda dan tim untuk berbagai merek, pemegang IP, dan artis musik dari seluruh dunia.Lihat pengembang merek terkemuka saat ini [Notable Brand Developers](https://create.roblox.com/talent/search/notable-brand-developers).Pengembang ini juga akan menjadi Mitra Pencipta Merek resmi dan akan menerima lencana, sebagai bagian dari Program Mitra Roblox.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-programs/partner-program.png' alt='Partner Program logo.' title='' width='400' height='' />Status: Open
## [Kelayakan](#kelayakan)
* Dipublikasikan setidaknya 1 pengalaman dengan 4M\+ MAU dan skor 65% seperti
* Sudah membangun pengalaman khusus untuk merek, IP, atau artis di Roblox.(Kami mendorong Anda untuk mengekspresikan minat bahkan jika Anda belum membangun pengalaman khusus untuk merek untuk kesempatan ditampilkan di masa depan.)
* profil[Hub Bakat](https://create.roblox.com/talent/) yang diperbarui, terperinci, dan lengkap
* Penuhi standar komunitas kami [dan memiliki riwayat moderasi akun dalam keadaan baik](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Standards)
* Pengembang yang mengirimkan surve harus berusia di atas 18 tahun. Jika Anda bekerja di grup/studio, silakan memiliki pemilik mengirim atas nama tim.
Anggota tim kami akan menghubungi Anda dengan langkah berikutnya melalui informasi kontak yang Anda berikan.Untuk informasi lebih lanjut, lihat [Roblox untuk Merek](https://brands.roblox.com/).
[Terapkan](https://survey.roblox.com/jfe/form/SV_802xyrv9VHb7VHM)
## [Informasi kontak](#informasi-kontak)
Program [Mitra@roblox.com](/docs/id-id/mailto%3AMitra%40roblox.com)
| 60 |
https://create.roblox.com/docs/id-id/creator-programs/feedback
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Program Umpan Balik Komunitas
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/feedback).
Program Umpan Balas Komunitas dirancang untuk mengumpulkan kelompok aktif dan pencipta tepercaya yang beragam untuk berkolaborasi dan bekerja erat dengan staf Roblox.
Status: Open
Sebagai bagian dari program ini, Anda adalah:
* Anggota Grup Umpan Balik Komunitas
* Salah satu yang pertama menerima pendaftaran untuk produk beta, kelompok fokus, koneksi 1:1, dan jam kantor
* Promosikan ke tingkat kepercayaan Reguler di Forum Developer
* Diberikan akses ke kategori Forum Pengembang Pribadi Program Umpan Balas Komunitas
* Diberikan akses ke Program Umpan Balas Komunitas Guilded Server. Guilded memberikan akses langsung ke tim pilihan.
* Roblox swag fisik berbakat sebagai hadiah untuk partisipasi
## [Kelayakan](#kelayakan)
Kelayakan dapat termasuk, tetapi tidak terbatas pada:
* Telah berkontribusi pada pengembangan pengalaman yang telah menunjukkan beberapa kesuksesan di platform
* Mengelola kelompok besar dengan komunitas aktif
* Membuat sumber daya komunitas yang telah membantu banyak
* Aset avatar yang dirancang yang telah tumbuh menjadi baris pakaian Roblox populer
## [Cara menerapkan](#cara-menerapkan)
Isi aplikasi di bawah ini. Staf Roblox meninjau aplikasi setiap tiga bulan dan akan menghubungi jika Anda telah dipilih.
[Terapkan](https://devforum.roblox.com/t/community-feedback-program-application/1034529)
| 61 |
https://create.roblox.com/docs/id-id/creator-programs/creator-events
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Peristiwa Pencipta
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/creator-events).
Sebagai kreatorRoblox, Anda dapat menyelenggarakan acara virtual melalui program Acara Pencipta Roblox.Jika Anda tertarik untuk berpartisipasi, [terapkan](https://survey.roblox.com/jfe/form/SV_cSnxeXTXIbKFz0i) untuk menjadi pengatur acara sukarela untuk Program Peristiwa Pencipta.
Untuk melihat pratinjau acara yang dihosting oleh pencipta komunitas kami, kunjungi halaman [acara masa lalu](https://events.roblox.com/home/content) yang berisi perpustakaan video acara masa lalu kami.Alternatifnya, RSVP ke acara mendatang [di sini](https://events.roblox.com/home/events) .
Status: Open
## [Persyaratan](#persyaratan)
* Anda harus berusia 16 tahun atau lebih.
* Anda nyaman dengan pidato publik.
### [Senang untuk memiliki (tidak diperlukan)](#senang-untuk-memiliki-tidak-diperlukan)
* Pengalaman sebelumnya dalam menyelenggarakan acara, baik secara langsung atau virtual.
* Keterampilan organisasi dan komunikasi yang baik.
* Pengalaman dengan membuat pengalaman atau aset di Roblox.
* Reputasi dengan komunitas Roblox diperoleh dari aktivitas yang Anda libatkan di Roblox, seperti pengalaman dan kelompok.
* Pengalaman dengan alat presentasi, seperti PowerPoint dan Google Slides.
## [Proses aplikasi](#proses-aplikasi)
Isi aplikasi dengan hati\-hati untuk memulai proses.Setelah kami menerima aplikasi Anda, Anda harus mendengar dari kami dalam 2–3 minggu.Volume aplikasi besar dapat menyebabkan penundaan.
[Terapkan](https://survey.roblox.com/jfe/form/SV_cSnxeXTXIbKFz0i)
### [Setelah penerimaan awal](#setelah-penerimaan-awal)
Anda perlu menyiapkan materi berikut jika aplikasi Anda lulus seleksi awal:
1. Sebuah submisi video pendek menjawab pertanyaan berikut. Anda dapat merekam video Anda dengan perangkat apa pun, termasuk ponsel Anda.
* Ceritakan tentang diri Anda.
* Beri tahu kami tentang komunitas yang telah Anda bangun atau saat ini sedang membangun kota.
* Beritahu kami di mana Anda berencana menyelenggarakan acara Anda.
2. Sebuah wawancara video dengan staf program.
* Kami mungkin meminta lebih banyak rincian setelah mengirimkan video Anda.
* Ini adalah kesempatan Anda untuk menanyakan pertanyaan kepada kami juga.
Kami telah membuat buku panduan untuk Organisasi Acara Sukarela kami untuk membantu Anda mendapatkan wawasan dan dukungan dalam menyelenggarakan acara.Kami juga memiliki server Guilded untuk Organisasi Peristiwa untuk berkomunikasi satu sama lain untuk menukar tips dan saran berguna.
## [Detail keanggotaan program](#detail-keanggotaan-program)
Sebagai Organisator Acara sukarela, Anda dapat:
* Buat acara di halaman acara [Roblox](https://events.roblox.com).
* Bergabunglah dengan komunitas yang penuh dengan pencipta berpikiran serupa.
* Akses ke buku panduan khusus yang telah kami buat untuk memberi Anda dukungan dan wawasan lebih lanjut.
* Akses ke gru [Forum Pengembang Organisator Acara](https://devforum.roblox.com/g/Event_Organizers).
## [Kontak](#kontak)
Jika Anda memiliki pertanyaan atau kekhawatiran tentang program ini, silakan hubungi staf program [apa pun](https://devforum.roblox.com/g/Events_Staff) di DevForum.Alternatifnya, Anda dapat mengirim email ke kami di [dev\-events@roblox.com](/docs/id-id/mailto%3Adev-events%40roblox.com).
| 62 |
https://create.roblox.com/docs/id-id/creator-fund
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Dana Pencipta
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-fund).
Program Dana Pencipta adalah untuk pencipta dan pengembang yang ingin membangun generasi berikutnya pengalaman di Roblox.Tujuan kami adalah bekerja erat dengan Anda untuk memberikan dana, dukungan, dan wawasan untuk pengembangan konten Anda.Pendanaan untuk peserta yang disetujui dimulai dari minimum $500\.000 per proyek.
Dengan peluncuran Dana Pencipta, kami ingin pengembang baru dan lama memiliki sumber daya yang diperlukan untuk membangun sesuatu yang istimewa dan membawa orang bersama\-sama melalui permainan.Program ini dirancang untuk mendukung pengembang yang ingin mendorong batas apa yang dapat diberikan pengalaman Roblox.
Status: Closed
## [Proyek yang memenuhi syarat](#proyek-yang-memenuhi-syarat)
Kami mencari proyek ambisius dan inovatif yang memungkinkan ide\-ide kreatif yang tidak seperti apa pun di platform.
Kami men prioritaskan proyek yang meliputi:
* Berfokus pada multiplayer.
* Lintas platform, dengan optimisasi seluler dalam pikiran.
* Mekanik sosial sebagai kunci pengalaman.
* Pengembalian kuat, Monetisasi, dan rencana operasi langsung.
* Avatar dalam pengalaman yang mencerminkan elemen identitas avatar platform pengguna.Kemampuan untuk memanfaatkan item yang dapat Anda pasang pada avatar platform, seperti yang Anda beli di [Pasar](https://www.roblox.com/catalog).
Jika Anda diterima ke dalam program, kami bermitra dengan Anda untuk mendefinisikan output kunci untuk proyek Anda dan memberikan dana berdasarkan kemajuan Anda terhadap tonggak ini.
| 63 |
https://create.roblox.com/docs/id-id/creator-programs/spotlights
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Sorotan Pencipta
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/spotlights).
Spotlight Pencipta adalah artikel DevForum mendalam yang merayakan hal\-hal mengagumkan yang dicapai oleh pencipta kami.Tujuan kami untuk program ini adalah untuk meningkatkan berbagai kreator yang berkembang di platform kami.Melalui sorotan kami, Anda dapat berbagi kisah Anda, memberikan tips dan saran, dan berbagi apa pun yang menarik datang ke rekan\-rekan pengembang dan kreator Roblox.
Status: Open
## [Kelayakan](#kelayakan)
* Berusia setidaknya 13 tahun (jika di bawah 18 tahun, harus memiliki persetujuan orangtua/wali)
* Telah dikembangkan di Roblox selama setidaknya 1 tahun dan telah berkontribusi pada konten yang menarik
* Penuhi Standar Komunitas kami [Community Standards](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Standards)
## [Cara berpartisipasi](#cara-berpartisipasi)
1. Isi formulir nominasi di bawah ini (nominasikan diri Anda atau kreator lain). Nominasi disetujui setiap minggu.
2. Terima pengikutan dari tim DevRel.Karena volume aplikasi yang tinggi, hanya mereka yang dianggap untuk sorotan akan dihubungi.Jika Anda belum mendengar kembali dalam waktu sebulan, kami mendorong Anda untuk menerapkan kembali dalam 6\-12 bulan.Pastikan untuk fokuskan aplikasi Anda pada keahlian domain Anda dan apa yang akan dipelajari oleh pencipta lain dari Anda.
3. Bergabunglah dengan panggilan Zoom dengan anggota tim DevRel untuk berbagi latar belakang, keahlian, dan saran Anda.
4. Berikan aset visual dan contoh pekerjaan.
[Terapkan](https://survey.roblox.com/jfe/form/SV_71CLpOMprlzQ8JM)
## [Contoh masa lalu](#contoh-masa-lalu)
* [Di Balik Permainan: Balapan Tengah Malam: Tokyo, Berpakaian untuk Mengesankan, dan Zombie Michael](https://devforum.roblox.com/t/behind-the-games-midnight-racing-tokyo-dress-to-impress-and-michael%E2%80%99s-zombies/3131289)
* [Sorotan Pencipta: Perjalanan BelowNatural Membangun Paradoxum Permainan](https://devforum.roblox.com/t/creator-spotlight-belownatural%E2%80%99s-journey-building-paradoxum-games/3027035)
* [Sorotan Pencipta: bagaimana menghapus desain UI untuk kelereng, putri duyung, dan banyak lagi](https://devforum.roblox.com/t/creator-spotlight-how-unroot-designs-ui-for-marbles-mermaids-and-more/3077233)
* [Sorotan Pencipta: Temui Ahlvie, Artis Lingkungan di Balik Dunia Fantastis](https://devforum.roblox.com/t/creator-spotlight-meet-ahlvie-the-environmental-artist-behind-fantastical-worlds/2964648)
| 64 |
https://create.roblox.com/docs/id-id/creator-programs/developer-awards
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Penghargaan Pengembang
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/developer-awards).
Penghargaan Pengembang adalah program berbasis data yang dirancang untuk menghargai pengembang karena mencapai tonggak penting dalam permainan mereka.Program ini bertujuan untuk mengenali dan merayakan pencapaian dan kontribusi pengembang ke platform.Dengan memenuhi kriteria tertentu, pengembang dapat memperoleh penghargaan yang mencerminkan dedikasi dan berhasilmereka.
Status: Open
## [Kategori penghargaan](#kategori-penghargaan)
* Barang Virtual
+ Metrik: Pengguna Aktif Bulanan (MAU)
+ Pengembang menerima mahkota (s) untuk avatar mereka setiap tonggak yang dicapai permainan mereka:
- 100\+ MAU
- 1K\+ MAU
- 10K\+ MAU
- 100K\+ MAU
- 1M\+ MAU
- 10JT\+ MAU
- 100M\+ MAU
- 1B\+ MAU
* Tas Sampah
+ Metrik: 40M\+ kehidupan Robux yang diperoleh (rolling 12 bulan)
+ Pengembang menerima tas swag untuk diri mereka sendiri dan beberapa rekan tim. Item termasuk:
- Ransel
- Sepatu kaki
- Topi
- Kaus Keringat
* Piala
+ Metrik: Jam Bermain Seumur Hidup
+ Pengembang menerima trofi untuk setiap tonggak yang tercapai:
- 10Jam\+ Hari
- 20Jam\+ Hari
- 50Jam\+ Hari
- 100Jam\+ Hari
- 250Juta\+ Jam
- 1B\+ Jam
- 5B\+ Jam
- 10B\+ Jam
## [Kelayakan](#kelayakan)
* Harus setidaknya berusia 13 tahun
* Harus menjadi pemilik pengalaman Anda
## [Menerima penghargaan](#menerima-penghargaan)
Tidak ada aplikasi. Roblox akan menghubungi mengenai tas swag dan trofi.
## [Informasi kontak](#informasi-kontak)
[devawards@roblox.com](/docs/id-id/mailto%3Adevawards%40roblox.com)
| 65 |
https://create.roblox.com/docs/id-id/creator-programs/inspire
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Menginspirasi
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/inspire).
Inspire adalah acara online global tahunan di mana pencipta berkumpul untuk bertukar ide, belajar dari workshop yang dipimpin oleh pencipta teratas, dan berkolaborasi untuk meningkatkan koneksi di komunitas.Dengan berpartisipasi, Anda dapat berbagi pengetahuan Anda dan menyelenggarakan workshop untuk komunitas pencipta yang lebih luas.
Lihat [Roblox Learn](https://www.youtube.com/@RobloxLearn) untuk konten dari Inspire 2024\.
Status: Open
## [Kelayakan](#kelayakan)
* Harus setidaknya berusia 16 tahun
* Penyaman dengan pidato publik
* Penuhi Standar Komunitas kami [Community Standards](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Standards)
## [Cara berpartisipasi](#cara-berpartisipasi)
* Isi [survei ini](https://survey.roblox.com/jfe/form/SV_3XbrWPyHsu4Q742) pada 28 Februari 2025\.
* Jika dipilih, bergabunglah dengan panggilan Zoom di mana anggota tim DevRel dapat lebih mengevaluasi keahlian pada topik pilihan Anda, bersama dengan keterampilan berbicara publik Anda.
* Siapkan workshop Anda dan hadir di Inspire.
## [Informasi kontak](#informasi-kontak)
[devrel\-inspire@roblox.com](/docs/id-id/mailto%3Adevrel-inspire%40roblox.com)
| 66 |
https://create.roblox.com/docs/id-id/creator-programs/learn-explore-sort
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Pelajari \& Jelajahi Urutan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/learn-explore-sort).
Sortir [Pelajari \& Jelajahi](https://www.roblox.com/charts#/sortName/Learn_And_Explore) menyoroti pengalaman yang memungkinkan pengguna belajar dengan cara yang menarik.Pengalaman ini harus membawa subjek seperti sejarah atau sains ke kehidupan dengan cara yang membuat siswa terlibat dan termotivasi untuk menjelajahi, bermain, dan berpikir mendalam.Melalui urutkanini, Anda dapat menerima pengakuan sebagai pengembang pendidikan yang dapat dipercaya dan meningkatkan peluang penemuan sebagai pengalaman pendidikan.
Status: Open
## [Kelayakan pengalaman](#kelayakan-pengalaman)
* Mengeksplorasi subjek, seperti sains, sejarah, atau matematika, atau memiliki nilai pendidikan yang jelas bagi seorang pendidik
* Tidak mengizinkan pengguna untuk menemukan monetarisasi agresif sebagai bagian dari pengalaman pengguna pertama mereka.Monetarisasi tidak boleh mengurangi pembelajaran atau permainan (yaitupengguna harus membayar untuk mengakses bagian besar konten atau mendapatkan keuntungan tidak adil dalam permainan karena Monetisasi.)
* Tetap sesuai untuk kelas untuk siswa dari segala usia, bahkan jika berisi materi pelajaran yang canggih
* Seperti rasio di atas 50% dan mempertahankan setidaknya 15 pengguna bersamaan
## [Cara menerapkan](#cara-menerapkan)
Kirim melalui form di bawah ini.Karena volume aplikasi yang tinggi, hanya mereka yang dianggap untuk kategori Pelajari \& Jelajahi akan dihubungi.Aplikasi disetujui oleh tim Pendidikan di Roblox setiap 1\-2 bulan.
[Terapkan](https://roblox.qualtrics.com/jfe/form/SV_8313iVKrwkQUiGy)
| 67 |
https://create.roblox.com/docs/id-id/creator-programs/managed-brand-integrations
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Integrasi Merek yang Dikelola
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/managed-brand-integrations).
Program Integrasi Merek Terkelola adalah untuk pencipta yang tertarik pada integrasi merek.Program ini menargetkan merek yang berinvestasi di Roblox dan ingin terintegrasi ke pengalaman populer.
Roblox mengelola seluruh proses untuk merek, termasuk koordinasi dengan pencipta untuk membawa integrasi ini ke kehidupan.Ini adalah kesempatan yang sangat baik bagi para pencipta untuk bekerja dengan Roblox dan merek terkemuka pada integrasi inovatif.Pembuat akan memiliki akses ke peluang berbayar untuk mengintegrasikan merek ke dalam pengalaman mereka dan kesempatan untuk berkolaborasi dengan merek profil tinggi.
Status: Open
## [Kelayakan](#kelayakan)
Ini saat ini adalah program undangan saja. Namun, untuk meningkatkan kemungkinan diundang, pencipta seharusnya idealnya:
* Miliki pengalaman dengan lebih dari 500k Pengguna Aktif Bulanan (MAU)
* Berkomunikasi dengan cara yang tepat waktu
* Memiliki keterampilan organisasi yang baik
* Bersedia untuk bekerja sama erat dengan merek
Setelah dipilih:
* Pembuat akan menerima undangan di DevForum untuk bergabung dengan server program.
* Pembuat diharapkan untuk bekerja dengan staf program untuk membuat dek khusus yang dapat dibagikan dengan merek pada kesempatan integrasi.
* Pembuat diharapkan untuk mempertimbangkan peluang, terlibat dengan merek dalam percakapan eksplorasi, dan berkolaborasi dalam proyek integrasi.
| 68 |
https://create.roblox.com/docs/id-id/creator-programs/notable-translators
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Program Penerjemah Terkenal
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/notable-translators).
Program Penerjemah Terkenal (Pilot) bertujuan untuk memberikan lebih banyak visibilitas kepada penerjemah komunitas yang berdedikasi dan berpengalaman yang ingin menawarkan layanan mereka kepada pencipta Roblox lainnya.Kami juga ingin memudahkan pembuat untuk menemukan dan mempekerjakan penerjemah komunitas berkualitas untuk membantu membuat pengalaman mereka menarik bagi pengguna di seluruh dunia.
Status: Open
## [Kelayakan](#kelayakan)
* Berusia setidaknya 18 tahun
* Memiliki akun Roblox [Verifikasi ID Usia](https://en.help.roblox.com/hc/en-us/articles/4407282410644-Age-ID-Verification)
* Memiliki akun Roblox yang berusia setidaknya 2 bulan
* Memiliki kemampuan bahasa asli atau hampir asli dalam bahasa yang Anda uji
## [Cara berpartisipasi](#cara-berpartisipasi)
Silakan gunakan salah satu tautan di bawah ini untuk mengambil tes terjemahan. Hanya satu entri per kandidat.
* [Inggris \> Tes Terjemahan Jerman](https://docs.google.com/forms/d/e/1FAIpQLSfwtTgKdNcwHfpvhGW1OFYz1lMzbdBf0AUbUP6JOS4Sn4WFXQ/viewform)
* [Inggris \> Tes Terjemahan Jepang](https://docs.google.com/forms/d/e/1FAIpQLSdjdN0JcmKfxsPCHJgwCO7MCkbN7WPWczy6g_38VwVBzRTm7Q/viewform)
* [Inggris \> Tes Terjemahan Thailand](https://docs.google.com/forms/d/e/1FAIpQLSdihHNOQdTc_Ug91CpeFAjVqFDsvSuTb8_z_FNnWfNxFysAKg/viewform)
Anda dapat mengharapkan untuk menerima hasil tes Anda melalui email dalam beberapa minggu setelah pengiriman.Kami berencana untuk memperluas program ini ke pasangan bahasa lebih lanjut dan menambah lebih banyak penerjemah ke daftar dalam beberapa bulan ke depan.Lihat daftar saat ini dari [Penerjemah Terkenal](https://devforum.roblox.com/t/notable-translators-program/3136858).
## [Penyangkalan](#penyangkalan)
Roblox tidak memposting pekerjaan, melakukan pekerjaan, atau mempekerjakan individu atau tim untuk melakukan pekerjaan bagi penerjemah yang diposting di Program Penerjemah Pencipta, dan tidak ada yang akan menciptakan hubungan pekerjaan, agensi, atau joint venture antara Roblox dan penerjemah mana pun.Roblox bukan pihak dalam perjanjian apa pun yang mungkin ditangani penerjemah, tidak mengawasi, mengarahkan, atau mengendalikan kinerja, kompensasi, atau pembelian layanan di Program Penerjemah Komunitas, dan tidak akan bertanggung jawab atau bertanggung jawab atas klaim atau kerusakan terkait dengannya, termasuk, tanpa batasan, jika seorang penerjemah tidak dibayar untuk pekerjaan mereka atau jika Pencipta Kerja membayar pekerjaan yang tidak diselesaikan oleh seorang penerjemah.Roblox juga tidak melakukan representasi atau jaminan mengenai kualitas pekerjaan yang dapat dilakukan oleh penerjemah dalam kaitannya dengan pekerjaan atau layanan yang dilakukan untuk Pencipta Pekerjaan.Roblox tidak merekomendasikan atau mendukung terjemahan atau Pencipta Pekerjaan tertentu, atau layanan atau posting pekerjaan yang ditawarkannya masing\-masing.
| 69 |
https://create.roblox.com/docs/id-id/creator-programs/rdc
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Konferensi Pengembang Roblox
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/rdc).
Konferensi Pengembang Roblox (RDC) kembali sebagai acara virtual dan tatap muka di San Jose pada 5\-6 September 2025!
RDC adalah acara undangan saja yang membawa bersama pengembang Roblox, merek, dan kreator di seluruh dunia.Akan ada peluang jaringan, sesi brainstorming mendalam, demonstrasi produk, dan jam kantor \- semua dirancang untuk memberdayakan kesuksesan Anda dan menampilkan masa depan Roblox.
Status: Open
Pembuat akan menerima undangan ke Konferensi Pengembang Roblox tahunan.Undangan ini bisa untuk hadir secara langsung atau untuk menonton virtual.Perhatikan DevForum untuk pembaruan mengenai konferensi setiap tahun.Kami mengumumkan "Save the Date" dan ketika pendaftaran dibuka.
Untuk beberapa contoh pidato utama Konferensi Pengembang Roblox, pembicaraan, dan sesi Q\&A, lihat [RDC 2024 playlist YouTube](https://www.youtube.com/playlist?list=PLuEQ5BB-Z1PJi8RJ7Kuc0JhcT0ubgaL43).
| 70 |
https://create.roblox.com/docs/id-id/creator-programs/innovation-awards
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Penghargaan Inovasi Roblox
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/innovation-awards).
Penghargaan Inovasi Roblox (RIAS) merayakan pencipta paling inovatif, bintang video, dan pengalaman setiap tahun, yang dipilih oleh komunitas.
Status: Open
Nominasi sekarang terbuka untuk Penghargaan Inovasi Roblox (RIAS).Untuk terlibat, cukup isi formulir nominasi .Nominasi akan ditutup pada 16 Juni pukul 17:00 PST.
Kategori penghargaan untuk 2025 adalah:
* Pengalaman Baru Terbaik
* Pilihan Orang
* Kolaborasi Terbaik
* Penggunaan IP Terbaik
* Penggunaan Terbaik dari Pemasaran Imersif
* Pengalaman Petualangan Terbaik
* Pengalaman Terbaik \& Kasual Partai \& Kasual
* Pengalaman Obby \& Platformer Terbaik
* Pengalaman Bertahan Terbaik
* Pengalaman Roleplay \& Avatar Sim Terbaik
* Pengalaman Simulasi Terbaik
* Pengalaman Puzzle Terbaik
* Pengalaman Balap Terbaik
* Pengalaman Olahraga Terbaik
* Pengalaman Strategi Terbaik
* Pengalaman Aksi Terbaik
* Pengalaman Penembak Terbaik
* Pengalaman RPG Terbaik
* Pencipta UGC Terbaik
* Bintang Video Terbaik
| 71 |
https://create.roblox.com/docs/id-id/creator-programs/research-panel
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Panel Penelitian Roblox
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/research-panel).
Panel Penelitian Roblox [adalah program eksklusif di mana orang dapat berbagi pendapat dan wawasan mereka untuk membantu meningkatkan Roblox](https://robloxresearchpanel.com/).Dengan berpartisipasi dalam survei, polling, dan diskusi, Anda secara langsung berkontribusi untuk meningkatkan pengalaman Roblox bagi semua orang.Roblox bermitra dengan Fuel Cycle, perusahaan penelitian pasar, untuk menyelenggarakan panel.
Status: Open
## [Mengapa berpartisipasi?](#mengapa-berpartisipasi)
Sebagai anggota berharga dari komunitas Roblox, umpan balik Anda sangat penting. Dengan bergabung ke Panel Penelitian Roblox, Anda dapat:
* Pengaruh Roblox: Insight Anda membantu membentuk fitur dan perbaikan baru.
* Dapatkan Hadiah: Berpartisipasi dalam aktivitas untuk mendapatkan poin, dapat ditukarkan untuk berbagai kartu hadiah.
* Dengar: Libatkan dalam diskusi berarti dengan anggota lain dan berikan umpan balik yang penting.
## [Tipe penelitian](#tipe-penelitian)
* Survei: Bagikan pemikiran Anda melalui surve terperinci tentang berbagai topik.
* Polling: Berikan pendapat cepat Anda tentang topik tertentu melalui polling pendek.
* Diskusi: Bergabunglah dalam diskusi mendalam dan berikan umpan balik berharga tentang ide dan fitur baru.
* Pengujian: Coba fitur Roblox baru.
## [Cara bergabung](#cara-bergabung)
Bergabung dengan Panel Penelitian Roblox hanya dengan undangan.
Kami mengundang pengguna Roblox untuk bergabung dengan panel dengan berbagai cara termasuk email, intersepsi surve di situs web atau aplikasi Roblox, atau posting di DevForum Roblox.Komunikasi ini akan berisi semua informasi yang diperlukan dan tautan untuk menyelesaikan pendaftaran Anda.
| 72 |
https://create.roblox.com/docs/id-id/creator-programs/todays-picks-home
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Pilihan Hari Ini di Rumah
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/todays-picks-home).
Pilihan Hari Ini di Rumah adalah kurasi pengalaman terbaik setiap hari.Kami menyoroti pembaruan menarik, pengalaman baru dan menonjol, acara, momen musiman dan/atau budaya untuk memperkenalkan konten segar dan menarik kepada pengguna Roblox.
Status: Open
## [Mengapa mengajukan?](#mengapa-mengajukan)
Kreasi luar biasa Anda adalah apa yang membuat Roblox istimewa, dan kami senang menampilkan lebih banyak dari mereka di Rumah, memberi Anda eksposur tambahan di platform kami.
## [Cara menerapkan](#cara-menerapkan)
Jika Anda ingin mengusulkan pengalaman Anda untuk ditampilkan di Pilihan Hari Ini, silakan selesaikan surve di bawah ini.Tim editorial kami meninjau nominasi secara berkala.Karena volume aplikasi yang tinggi, hanya mereka yang dipilih untuk Pilihan Hari Ini di Rumah akan diberitahu.Jika Anda belum mendengar kembali, kami mendorong Anda untuk mengisi formulir setiap kali pengalaman Anda memiliki updateyang signifikan.
[Terapkan](https://survey.roblox.com/jfe/form/SV_cHDxf7DtHltY4US)
| 73 |
https://create.roblox.com/docs/id-id/creator-programs/todays-picks-marketplace
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Ringkasan](/docs/id-id/platform)
Bahasa Indonesia
Masukan
# Pilihan Hari Ini di Pasar
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creator-programs/todays-picks-marketplace).
Pilihan Hari Ini di Pasar adalah jenis yang dipilih dengan item yang dipilih setiap hari oleh tim editor internal.Kami berusaha untuk menghubungkan setiap pengguna dengan item avatar yang membantu mereka membawa diri unik mereka ke platform.
Status: Open
## Mengapa mengajukan?
Menggunakan upaya gabungan dari tim editor Roblox kami dan sistem rekomendasi Pasar kami, Pilihan Hari Ini di Pasar akan memberi kami lebih banyak cara untuk menampilkan pekerjaan dan kreativitas yang Anda bawa ke Roblox.:
## Kualifikasi
* Jadilah 17\+ dan diverifikasi ID
* Penuhi Standar Komunitas kami [dan Kebijakan Pasar](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Standards)
## Cara menerapkan
Isi survei di bawah ini untuk menominasikan item Anda.Kami meninjau submit baru setiap minggu.Karena volume aplikasi yang tinggi, hanya mereka yang dipilih untuk Pilihan Hari ini di Pasar akan dihubungi.Jika Anda tidak mendengar balasan, kami mendorong Anda untuk menerapkan kembali saat Anda memiliki item baru untuk kirim.:
[Terapkan](https://survey.roblox.com/jfe/form/SV_8cZb94oj9OvQm9g)<img src='https://prod.docsiteassets.roblox.com/assets/misc/Todays-Picks-Marketplace.png' alt='' title='' width='85%' height='' />
| 74 |
https://create.roblox.com/docs/id-id/experiences
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
Bahasa Indonesia
Masukan
# Mulai dengan pengalaman di Roblox
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/experiences).
Roblox adalah platform penciptaan 3D yang menyediakan IDE all\-in\-one yang mencakup Roblox Engine, emulator klien, dan semua alat dan API yang Anda butuhkan untuk mulai membuat pengalaman Roblox.
Dapatkan Studio dan ambil turDapatkan beradaptasi dengan Studio dengan mengunduh dan meluncurkan tur onboarding.Download Studio
Buat pengalaman pertama AndaBuat ketapel yang meluncurkan bola ke blok saat mempelajari konsep Roblox penting.[Buat](/docs/id-id/./tutorials/first-experience)Edit di StudioPelajari tentang platformRoblox dirancang untuk dunia mega skala, 3D.Pelajari tentang cara kerjanya[Untuk Pengembang Unity](/docs/id-id/unity)[Untuk Pengembang Unreal](/docs/id-id/unreal)
## Bermain dan buat dengan templat
Roblox Studio memiliki berbagai templat yang dapat Anda ubah dan mainkan tanpa pengetahuan sebelumnya. Beri mereka kesempatan dan tambahkan kepada mereka saat Anda siap!
PlatformerBangun platform Anda sendiri 3D platformer dengan platform yang dapat disesuaikan, pengambilan koin, dan lompatan ganda, melaju, dan karakter mekanik loncatan panjangEdit di StudioTag laserBangun pemburu pertama Anda sendiri dengan peledak yang dapat disesuaikan, sistem bulat, dan aset pembangun modular untuk mengkonfigurasi ulang arena berkualitas tinggi!
[Bermain](roblox://placeId=17823019220)Edit di StudioBalapBangun kart pembalap sendiri dengan mekanik mengemudi yang dapat disesuaikan, titik pemeriksaan, dan bagian trek pengikat modular yang dapat Anda ubah untuk tak terhitung banyak trek!
[Bermain](roblox://placeId=16078915506)Edit di Studio
## Belajar dengan jalur kurikulum
Untuk menyelam lebih dalam, ikuti kurikulum terpandu yang mengajarkan Anda keterampilan yang Anda butuhkan untuk menciptakan dan memonetarisasi pengalaman Anda.
[https://www.youtube-nocookie.com/embed/zi0hIuPDyWc](https://www.youtube-nocookie.com/embed/zi0hIuPDyWc)
IntiInti mengajarkan Anda cara membangun platform 3D sederhana di mana pemain mengumpulkan koin untuk ditukar dengan kekuatan lompatan.[Buat](/docs/id-id/./tutorials/curriculums/core)Edit di Studio[https://www.youtube-nocookie.com/embed/nwShvDmFHWc](https://www.youtube-nocookie.com/embed/nwShvDmFHWc)
Seni lingkunganSeni lingkungan mengajarkan Anda cara membuat lingkungan berkualitas tinggi untuk pengalaman tag laser.[Buat](/docs/id-id/./tutorials/curriculums/environmental-art)Edit di Studio[https://www.youtube-nocookie.com/embed/7iJKUUiKc0Y](https://www.youtube-nocookie.com/embed/7iJKUUiKc0Y)
Skrip permainanSkrip permainan mengajarkan Anda cara mengatur dan menerapkan logika pemrograman untuk proyek besar dan kompleks.[Buat](/docs/id-id/./tutorials/curriculums/gameplay-scripting)Edit di Studio
## Hubungkan
Pelajari, berbagi, dan berinteraksi dengan komunitas Roblox di tempat\-tempat berikut.Di forum[Pengumuman staf](https://devforum.roblox.com/c/updates/announcements/36)[Artikel staf](https://devforum.roblox.com/c/resources/roblox-staff/278)[Tutorial komunitas](https://devforum.roblox.com/c/resources/community-tutorials/46)[Bantuan dan umpan balik komunitas](https://devforum.roblox.com/c/help-and-feedback/54)Di saluran video sosial[Saluran YouTube](https://www.youtube.com/@RobloxLearn)[Platform konten dan acara](https://events.roblox.com)
| 75 |
https://create.roblox.com/docs/id-id/creation
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
Bahasa Indonesia
Masukan
# Ulasan tentang penciptaan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/creation).
Pelajari semua yang perlu Anda ketahui tentang pembuatan di Roblox.Jika Anda baru mengembangkan pengalaman Roblox, baca panduan ini untuk tur ke penciptaan Roblox sebelum menyelami dokumentasi produk dan tutorial.
## [platformRoblox](#platformroblox)
Roblox gratis untuk digunakan oleh pengguna dan pembuat dan meliputi demografi luas dengan perilaku pengguna yang berbeda dari platform sosial lainnya.Pelajari apa yang membuat Roblox unik dan apa yang harus dipikirkan sebelum membuat.
#### Ringkasan
Pelajari tentang platform dan nilai unik kami.[Pelajari lebih lanjut](/docs/id-id/platform)
#### Dasar pengguna Roblox
Pelajari apa yang men karakterisasi audiens Roblox, dan faktor sosial dan budaya apa yang harus Anda pertimbangkan saat mengembangkan di platform.[Pelajari lebih lanjut](/docs/id-id/production/roblox-user-base)
#### Merancang untuk Roblox
Temukan beberapa praktik umum dari pengalaman sukses dan cari tahu bagaimana menyesuaikan desain Anda dengan karakteristik unik Roblox.[Pelajari lebih lanjut](/docs/id-id/production/game-design)
## [Pengalaman](#pengalaman)
Pengalaman adalah dunia 3D yang Anda buat dan publikasikan di Roblox.Pelajari bagaimana mereka bekerja secara teknis, sehingga Anda memahami cara membangun pengalaman terbaik yang mungkin untuk pengguna Anda.
#### Proyek Roblox
Memahami cara membangun proyek di Roblox Studio dan mempublikasikannya sebagai pengalaman di Roblox.[Pelajari lebih lanjut](/docs/id-id/projects)
#### Bekerja dengan aset
Memahami cara mengunggah aset ke cloud Roblox dan cara menggunakannya dalam proyek Anda.[Pelajari lebih lanjut](/docs/id-id/projects/assets)
#### Model data
Memahami model data, definisi dasar tentang bagaimana tempat dalam pengalaman 3D Anda terlihat dan berfungsi.[Pelajari lebih lanjut](/docs/id-id/projects/data-model)
#### Waktu eksekusi klien\-server
Memahami bagaimana pengalaman Anda berjalan di Cloud Roblox.[Pelajari lebih lanjut](/docs/id-id/projects/client-server)
#### Ruang kerja 3D
Ruang kerja 3D adalah tempat Anda mendefinisikan semua objek yang drender oleh Roblox.[Pelajari lebih lanjut](/docs/id-id/workspace)
#### Skrip
Pelajari cara menulis logika untuk pengalaman Roblox Anda.[Pelajari lebih lanjut](/docs/id-id/scripting)
#### Karakter
Memahami bagaimana model karakter bekerja untuk NPC dan Pemain di Roblox.[Pelajari lebih lanjut](/docs/id-id/characters)
#### Model dan meshes khusus
Memahami cara menggunakan Blender dan alat lain untuk membuat objek 3D khusus.[Pelajari Lebih Lanjut](/docs/id-id/art/modeling)
## [Roblox Studio](#roblox-studio)
Studio adalah IDE all\-in\-one yang memungkinkan Anda membuat di Roblox.Anda membangun proyek yang nantinya dapat dipublikasikan sebagai pengalaman ke Roblox dan juga menggunakan Studio untuk membuat karakter dan aksesori.
#### Ringkasan studio
Pelajari tentang Studio, IDE all\-in\-one untuk Roblox.[Pelajari lebih lanjut](/docs/id-id/studio/ui-overview)
#### Panduan UI
Pelajari tentang UI Studio dan semua fitur dan alat yang tersedia.[Pelajari lebih lanjut](/docs/id-id/studio/ui-overview)
## [Pencarian dan Monetisasi](#pencarian-dan-monetisasi)
Dengan puluhan juta pengguna aktif setiap hari, ada banyak cara untuk memonetarisasi dan menumbuhkan kreasi Anda.
#### Mempromosikan di Roblox
Temukan bagaimana pengalaman umumnya dipromosikan di Roblox dan bagaimana Anda dapat menghabiskan anggaran Anda paling sesuai.[Pelajari lebih lanjut](/docs/id-id/production/promotion)
#### Mendapatkan di Roblox
Pelajari tentang opsi dan strategi monetarisasi di platform bersama dengan pertimbangan terkait untuk pengembang.[Pelajari lebih lanjut](/docs/id-id/production/earn-on-roblox)
## [Avatar](#avatar)
Pelajari cara membangun model karakter dan aksesori di alat pihak ketiga seperti Blender dan Maya dan menjualnya di Pasar.Lihat [Avatar](/docs/id-id/avatar) untuk panduan pembuatan, spesifikasi teknis, dan sumber daya tambahan.
[Sebelumnya](/docs/id-id/platform)[Next](/docs/id-id/tutorials/first-experience)
| 76 |
https://create.roblox.com/docs/id-id/projects
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
Bahasa Indonesia
Masukan
# Proyek
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects).
Sebuah proyek Roblox adalah koleksi tempat , aset , pengaturan , dan sumber daya lain yang bersama\-sama mewakili pengalaman .Roblox menyimpan proyek Anda di cloud untuk kolaborasi, editing, dan kontrol versi yang nyaman.Anda membuat dan mengelola proyek dengan [Roblox Studio](/docs/id-id/studio), IDE all\-in\-one yang menyediakan alat membangun kota, scripting, pengujian, dan penerbitan.
## [Tempat](#tempat)
Pengalaman di Roblox terdiri dari tempat individu , mirip dengan adegan di Unity atau peta di Unreal Engine .Setiap tempat berisi semua komponen untuk bagian pengalaman itu, termasuk lingkungan khusus, bagian, meshes, skrip, dan antarmuka pengguna.Lihat [Pengalaman dan tempat](/docs/id-id/production/publishing/publish-experiences-and-places) untuk rincian tentang pembuatan dan manajemen pengalaman.
<img src='https://prod.docsiteassets.roblox.com/assets/publishing/experiences-places-assets/Experience-Hierarchy.png' alt='An experience grouping of three individual places with unique environments.' title='' width='800' height='' />
Setiap tempat diwakili oleh model data data , hierarki objek yang menggambarkan segala sesuatu tentang tempat.Mesin Roblox menggunakan model data sebagai sumber kebenaran untuk status tempat, sehingga dapat menyimulasikan dan menampilkannya di perangkat klien.Untuk informasi lebih lanjut tentang bagaimana mesin menafsirkan model data, lihat [waktu eksekusi klien\-server](/docs/id-id/projects/client-server).
Organisasi objek yang tepat dan disengaja dalam model data sangat penting untuk fungsi dan pemeliharaan proyek Anda.Untuk informasi lebih lanjut tentang objek apa yang tersedia dan cara mengatur dan menggunakannya, lihat [model data](/docs/id-id/projects/data-model).
## [Aktiva](#aktiva)
Di Roblox, aset seperti gambar, mesh, dan audio disimpan sebagai aset berbasis cloud , jadi Anda tidak perlu menggabungkan salinan lokal ke dalam pengalaman Studio yang disimpan.Setiap aset di cloud diberi ID aset unik dari mana banyak pengalaman dapat menggunakannya .Anda dapat membuat aset langsung di Studio, seperti model, atau impor aset seperti gambar, audio, dan meshes dari alat lain.
rbxassetid://7229442422
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Example-Grafitti04.png' alt='A decal asset of a young woman with a button for an eye.' title='' width='90%' height='' />
rbxassetid://6768917255
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/meshes/Base-Mesh-In-Marketplace.png' alt='An untextured treasure chest MeshPart asset.' title='' width='90%' height='' />
rbxassetid://9125402735
Secara default, aset pribadi untuk pengalaman Anda dan Anda dapat menggunakan aset di tempat mana pun dengan merujuk pada IDnya.Anda juga dapat mendistribusikannya ke komunitas di [Toko Pencipta](https://create.roblox.com/store/), sehingga orang lain dapat menggunakannya juga.
Untuk informasi lebih lanjut tentang cara mengimpor dan mempublikasikan aset, lihat [Aset](/docs/id-id/projects/assets).
## [Kemasan](#kemasan)
[Paket](/docs/id-id/projects/assets/packages) adalah hierarki objek yang dapat digunakan kembali yang dapat Anda definisikan dan gunakan kembali di banyak tempat di berbagai pengalaman.Untuk setiap proyek besar, paket menawarkan manfaat berikut:
* Paket dapat digunakan sebagai kit aset, memungkinkan Anda untuk menyalin satu set objek sesuai kebutuhan.
* Paket membuat lebih mudah untuk memperbarui aset.Sebagai kejadian, paket dapat mencakup pohon yang diulang berkali\-kali di lingkungan.Jika Anda perlu membuat perubahan, seperti mengganti teksur untuk pohon, itu dapat diperbarui sekali dalam paket alih\-alih untuk setiap instansi individu.
* Paket dapat dimulai dengan aset kotak abu\-abu, dan akhirnya digantikan dengan aset seni akhir.Ketika aset diganti, mereka mempertahankan semua posisi dan orientasi asli.
## [Pengaturan](#pengaturan)
Pengaturan pengalaman dikelola dari [Dashboard Pencipta](https://create.roblox.com/dashboard/creations) atau di dalam Studio, termasuk:
* Informasi Dasar — Informasi dasar tentang pengalaman, seperti namanya, deskripsinya, dan genre.Banyak informasi di sini digunakan dalam daftar pengalaman Anda.
* Komunikasi — Pengaturan yang memungkinkan pengguna yang memenuhi syarat menggunakan [obrolan suara](/docs/id-id/chat/voice-chat) atau menganimasikan avatar mereka melalui kamera dalam pengalaman Anda.
* Izin — Mengkonfigurasi siapa yang dapat mengakses pengalaman Anda.Pengalaman baru dimulai sebagai pribadi dan hanya dapat diedit dan bergabung oleh Anda dan anggota kelompok Anda [dengan izin yang benar](/docs/id-id/projects/groups).Saat sesuai, Anda dapat [melepaskan](/docs/id-id/production/publishing/publish-experiences-and-places#release-to-the-public) pengalaman kepada publik.
* Monetarisasi — Pilihan untuk mendapatkan pendapatan dari pengalaman Anda, seperti yang dijelaskan di [Monetarisasi](/docs/id-id/production/monetization).
* Lokalisasi — Konfigurasi untuk berbagai [bahasa dan wilayah](/docs/id-id/production/localization).
* Avatar — Pengaturan terkait dengan avatar, seperti skala avatar dan penghapusan pakaian.
## [Kolaborasi](#kolaborasi)
Dengan alat kolaborasi bawaan Studio , anggota tim dapat berkontribusi pada pengalaman secara mandiri pada waktu mereka sendiri, atau bersama orang lain.Fitur kunci termasuk:
* Admin grup dapat mengelola anggota mana yang memiliki akses untuk berkolaborasi dan mana yang tidak, secara efektif mempertahankan peran yang tepat dalam tim besar.
* Kolaborator dapat membangun bersama anggota tim lain dalam waktu nyata dan secara otomatis melihat perubahan yang dilakukan oleh orang lain.
* Kolaborator dapat secara independen mengedit skrip yang sama yang orang lain mungkin sedang mengedit, menguji secara lokal, dan mengkomitkan perubahan mereka ke proyek berbasis cloud saat siap.
Untuk informasi lebih lanjut, lihat [Kolaborasi](/docs/id-id/projects/collaboration).
## [Pengujian](#pengujian)
Tim Anda [dapat langsung menguji pengalaman di PC, seluler, VR, dan perangkat lain yang ingin Anda dukung melalui aplikasi Roblox; tidak perlu mengkompilasi build, dipublikasikan ke toko aplikasi, atau menunggu persetujuan toko aplikasi](/docs/id-id/projects/groups).
Studio menawarkan serangkaian opsi untuk menguji pengalaman sebelum dirilis ke publik:
* Pengujian cepat permainan yang memberikan simulasi dekat dari pengalaman yang berjalan di aplikasi Roblox.
* Simulasi multi\-klien untuk membandingkan bagaimana setiap klien "melihat" klien lain dalam pengalaman.
* Emulasi perangkat yang memberikan wawasan tentang bagaimana kontrol beroperasi di perangkat seluler atau bagaimana tampilan UI di layar menampilkan di berbagai layar dan rasio aspek.
* Pengujian bermain kolaboratif dengan anggota tim Anda.
Untuk informasi lebih lanjut tentang setiap opsi pengujian, lihat [mode pengujian Studio](/docs/id-id/studio/testing-modes).
| 77 |
https://create.roblox.com/docs/id-id/projects/data-model
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
6. /
7. [Arsitektur](/docs/id-id/projects/data-model)
Bahasa Indonesia
Masukan
# Model data
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/data-model).
Setiap tempat diwakili oleh model data, hierarki objek yang menggambarkan segala sesuatu tentang tempat.Model data berisi semua objek yang membentuk dunia 3D, seperti bagian, medan, pencahayaan, dan elemen lingkungan lainnya.Ini juga berisi objek yang dapat mengontrol perilaku runtime, seperti skrip yang mengubah properti, memanggil metode dan fungsi, dan menanggapi peristiwa yang memungkinkan perilaku dinamis dan interaktivitas.
Mesin Roblox menggunakan model data sebagai sumber kebenaran untuk status tempat, sehingga dapat menyimulasikan dan menampilkannya di perangkat klien.Untuk informasi lebih lanjut tentang cara Roblox Engine menafsirkan model data, lihat [Waktu Eksekusi Klien\-Server](/docs/id-id/projects/client-server).
## [Objek](#objek)
Anda menempatkan dan mengatur objek di model data untuk menggambarkan tempat di Roblox.Setiap objek di Roblox mewarisi dari kelas [Instance](/docs/id-id/reference/engine/classes/Instance) , yang mendefinisikan properti, metode, dan peristiwa umum yang ada di semua objek.Objek juga mendefinisikan karakteristik mereka sendiri tergantung pada fungsionalitas yang disediakan objek.Ada banyak kategori objek dengan berbagai penggunaan, tetapi Anda sering bekerja dengan [BasePart](/docs/id-id/reference/engine/classes/BasePart) dan [LuaSourceContainer](/docs/id-id/reference/engine/classes/LuaSourceContainer) objek, yang biasanya disebut sebagai bagian dan skrip.
Untuk daftar lengkap semua fitur dari Roblox Engine, lihat dokumentasi referensi [referensi](/docs/id-id/reference/engine).
### [Blok bangunan 3D](#blok-bangunan-3d)
[BasePart](/docs/id-id/reference/engine/classes/BasePart) adalah kelas utama untuk blok bangunan 3D fisik yang disimulasikan di dunia.Ini mendefinisikan properti dan metode umum untuk semua objek fisik dengan properti seperti posisi, ukuran, dan orientasi.
| Objek | Deskripsi |
| --- | --- |
| [Part](/docs/id-id/reference/engine/classes/Part) | Suku primitif [bagian](/docs/id-id/parts) yang dapat mengambil bentuk blok, bola, silinder, cekungan, atau cekungan sudut. |
| [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) | Sebuah mesh [导入](/docs/id-id/parts/meshes) dari perangkat lunak pemodelan 3D seperti Maya atau Blender. |
| [TrussPart](/docs/id-id/reference/engine/classes/TrussPart) | Sebuah balok rangka yang karakter dapat panjat seperti tangga. |
Meskipun secara teoritis Anda dapat membuat pengalaman Roblox yang sepenuhnya berfungsi menggunakan hanya bagian sederhana, Anda kemungkinan besar akan mengimpor [meshes](/docs/id-id/parts/meshes) dan menggabungkan bagian\-bagian primitif menjadi objek dan struktur yang lebih kompleks melalui [pemodelan solid](/docs/id-id/parts/solid-modeling).
### [Skrip](#skrip)
Anda dapat menambahkan interaktivitas dan perilaku ke dunia 3D tempat Anda dan mendefinisikan logika dengan skrip.Anda menulis skrip dalam bahasa pemrograman Luau untuk melakukan hal\-hal seperti memindahkan bagian, memanggil skrip lain, dan menanggapi peristiwa.Karena Roblox bekerja dalam model klien\-server, Anda dapat menjalankan skrip di server, klien, atau membiarkannya berkomunikasi melintasi batas jaringan.
* Sebuah objek [Script](/docs/id-id/reference/engine/classes/Script) mewakili skrip yang hanya dapat dijalankan di server.
* Sebuah objek [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) mewakili skrip yang hanya dapat dijalankan di klien.
* Sebuah objek [ModuleScript](/docs/id-id/reference/engine/classes/ModuleScript) mewakili skrip yang dapat digunakan ulang yang dapat Anda [require()](/docs/id-id/reference/engine/globals/LuaGlobals#require) dari kedua skrip server dan klien.
Untuk skrip agar berperilaku dengan benar, Anda harus menempatkannya di kontainer yang benar dalam model data.Untuk informasi lebih lanjut, lihat bagian [Server](#server) dan [Klien](#client).
## [Organisasi objek](#organisasi-objek)
Sementara Anda memiliki banyak fleksibilitas dalam cara Anda mengatur model data Anda, Roblox Engine mengharapkan objek tertentu berada di layanan wadah tertentu yang merupakan objek yang memiliki perilaku tertentu dan dapat mempengaruhi perilaku objek yang mereka berisi .Kategori utama layanan kontainer termasuk:
* Ruang kerja \- [Workspace](/docs/id-id/reference/engine/classes/Workspace) menyimpan semua objek yang ditampilkan di dunia 3D.
* Lingkungan \- Kontainer seperti [Lighting](/docs/id-id/reference/engine/classes/Lighting) dan [SoundService](/docs/id-id/reference/engine/classes/SoundService) yang berisi objek untuk pengaturan dan elemen lingkungan.
* Replikasi \- Kontainer untuk konten dan logika yang dipindahkan antara server dan klien, seperti [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) dan [ReplicatedFirst](/docs/id-id/reference/engine/classes/ReplicatedFirst) .
* Server \- Kontainer untuk konten dan logika sisi server saja, seperti [ServerScriptService](/docs/id-id/reference/engine/classes/ServerScriptService) dan [ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage).
* Klien \- Kontainer untuk konten dan logika sisi klien, seperti [StarterPlayer](/docs/id-id/reference/engine/classes/StarterPlayer) dan [StarterGui](/docs/id-id/reference/engine/classes/StarterGui) .
* Obrolan \- Kontainer untuk objek yang mengaktifkan fitur obrolan, seperti [VoiceChatService](/docs/id-id/reference/engine/classes/VoiceChatService) dan [TextChatService](/docs/id-id/reference/engine/classes/TextChatService) .
Mesin Roblox memiliki banyak layanan lain yang menyediakan fungsi bawaan yang dapat Anda panggil dalam skrip Anda.Mesin Roblox tidak memberikan perlakuan khusus pada layanan ini dalam model data.Untuk informasi lebih lanjut, lihat [Layanan](/docs/id-id/scripting/services).
Selain itu, Anda dapat lebih lanjut mengatur objek Anda dengan objek berikut:
* Folder \- A [Folder](/docs/id-id/reference/engine/classes/Folder) adalah untuk tujuan organisasi dan tidak mendefinisikan perilaku apa pun.Sebagai contoh, Anda dapat menggunakan folder untuk menggrup objek serupa seperti serangkaian skrip di penyimpanan server.
* Model \- A [Model](/docs/id-id/reference/engine/classes/Model) terutama dimaksudkan untuk kelompok geometris bagian, seperti menggrupkan bersama set meja yang memiliki kursi, meja, dan lampu.Untuk mengatur set yang lebih kompleks, Anda bahkan dapat menyusun model dalam model.
### [Ruang kerja](#ruang-kerja)
[Workspace](/docs/id-id/reference/engine/classes/Workspace) berisi semua objek yang membentuk dunia 3D tempat.Anda dapat menambahkan objek ke ruang kerja untuk menyesuaikan dunia 3D Anda, seperti bagian dasar, bagian meshes, dan model.Klien menampilkan semua yang muncul di kontainer ini dan tidak ada apa pun di luar itu, sehingga Anda dapat mengontrol apa yang dilihat dan berinteraksi dengan pengguna di tempat Anda.Meskipun tidak benar\-benar disajikan, Anda juga dapat menambahkan skrip yang terkait dengan bagian dan model yang mereka terkait dengan.Secara default, ruang kerja diisi sebelumnya dengan objek [Terrain](/docs/id-id/reference/engine/classes/Terrain) dan [Camera](/docs/id-id/reference/engine/classes/Camera).
#### Kameranya
[Camera](/docs/id-id/reference/engine/classes/Camera) menentukan bagaimana klien melihat dunia 3D.Secara default, ada satu kamera di ruang kerja, tetapi Anda dapat menambahkan beberapa objek kamera untuk membuat perspektif dan pandangan yang berbeda.Setiap klien mengambil pengaturan ini dan membuat pandangan kamera sendiri yang tidak dapat diubah langsung oleh server.
Sebagai contoh, Anda dapat menyetel kamera untuk mengikuti gerakan pengguna atau tetap tetap di lokasi tertentu.Anda juga dapat menyesuaikan bidang pandang, jarak, dan sudut untuk membuat efek visual berbeda tentang bagaimana pengguna melihat dunia 3D Anda.
Untuk informasi lebih lanjut, lihat [Sesuaikan kamera](/docs/id-id/workspace/camera).
#### Tanah
[Terrain](/docs/id-id/reference/engine/classes/Terrain) memungkinkan Anda untuk membuat lanskap untuk tempat Anda.Anda dapat menerapkan material ke medan untuk menyimulasikan lingkungan alami yang diinginkan, seperti rumput, air, pasir, atau bahan khusus.Meskipun Anda hanya dapat memiliki satu objek medan untuk dunia 3D Anda dan menerapkan satu bahan ke medan itu, Anda dapat menggunakan [Editor Medan](/docs/id-id/studio/terrain-editor) untuk mengedit wilayah medan Anda.
Untuk informasi lebih lanjut, lihat [Medan lingkungan](/docs/id-id/parts/terrain).
### [Lingkungan](#lingkungan)
Efek pencahayaan dan suara dapat membuat dunia 3D Anda lebih imersif dan realistis.Meskipun tidak perlu menambahkan efek ini ke tempat Anda, mereka dapat membuatnya lebih menarik secara visual dan akustik.
Selain menggunakan layanan lampu dan suara, Anda dapat menambahkan bagian yang memancarkan cahaya dan suara.Untuk informasi lebih lanjut, lihat [Efek Pencahayaan](/docs/id-id/effects/light-sources) dan [Objek Suara](/docs/id-id/sound/objects).
#### Penerangan
[Lighting](/docs/id-id/reference/engine/classes/Lighting) berisi objek yang mengontrol pengaturan pencahayaan global tempat anda, seperti [Atmosphere](/docs/id-id/reference/engine/classes/Atmosphere) untuk meniru efek atmosfer atau [Sky](/docs/id-id/reference/engine/classes/Sky) untuk mengubah matahari, bulan, dan bintang di lingkungan anda.
Untuk informasi lebih lanjut, lihat [Penerangan](/docs/id-id/environment/lighting).
#### Suara
[SoundService](/docs/id-id/reference/engine/classes/SoundService) dapat mengontrol volume dan pengaturan pemutaran objek anak [Sound](/docs/id-id/reference/engine/classes/Sound) untuk musik latar belakang atau efek suara alam.
Untuk informasi lebih lanjut, lihat [Suara](/docs/id-id/sound).
### [Replikasi](#replikasi)
Replikasi adalah proses server menyinkronkan status tempat Anda dengan semua klien yang terhubung.Mesin Roblox cerdas dan otomatis mereplikasi data, fisika, dan pesan obrolan antara server dan klien untuk banyak kasus, tetapi Anda juga dapat menentukan objek tertentu untuk direplikasi dengan menempatkannya di wadah khusus.
#### Diulang Pertama
[ReplicatedFirst](/docs/id-id/reference/engine/classes/ReplicatedFirst) berisi objek yang ingin Anda salin ke klien saat bergabung dengan tempat Anda.Biasanya berisi objek yang penting untuk menginisialisasi pemain, seperti objek sisi klien [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) dan objek yang terkait dengan skrip.Semua konten di dalam wadah ini di\-复制 dari server ke klien hanya sekali.
#### Penyimpanan Terulang
[ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) berisi objek yang tersedia untuk server dan klien yang terhubung.Setiap perubahan yang terjadi pada klien bertahan tetapi tidak akan dipindahkan ke server.Server dapat menulis ulang perubahan pada klien untuk menjaga konsistensi.Wadah ini biasanya digunakan untuk objek [ModuleScript](/docs/id-id/reference/engine/classes/ModuleScript) yang perlu dibagikan dan diakses oleh kedua objek [Script](/docs/id-id/reference/engine/classes/Script) (sisi server) dan [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) (sisi klien).Selain itu, Anda dapat menggunakan wadah ini untuk mereplikasi objek apa pun yang tidak perlu ada di dunia 3D sampai diperlukan, seperti [ParticleEmitter](/docs/id-id/reference/engine/classes/ParticleEmitter) untuk kloning dan pengasuh untuk semua model karakter yang masuk.
Untuk informasi lebih lanjut tentang cara kerja replikasi, lihat [jalan runtime klien\-server](/docs/id-id/projects/client-server).
### [Pelayan](#pelayan)
Model data mendefinisikan kontainer khusus hanya untuk objek sisi server yang tidak pernah direplikasi ke klien.Ini memungkinkan server untuk mempengaruhi perilaku dan status klien tanpa mengekspos objek dan logika server ke klien.
Anda dapat menggunakan acara dan fungsi remote untuk memungkinkan komunikasi sisi klien dengan server.
#### Layanan Skrip Server
[ServerScriptService](/docs/id-id/reference/engine/classes/ServerScriptService) berisi [Script](/docs/id-id/reference/engine/classes/Script) objek, [ModuleScript](/docs/id-id/reference/engine/classes/ModuleScript) objek yang diperlukan oleh skrip server, dan objek terkait skrip lain yang hanya dimaksudkan untuk penggunaan server.Jika skrip Anda membutuhkan objek lain, non\-skrip, Anda harus menempatkannya di [ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage) .Skrip di kontainer ini tidak pernah direplikasi ke klien, yang memungkinkan Anda memiliki logika sisi server yang aman.
#### Penyimpanan Server
[ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage) berisi objek yang hanya dimaksudkan untuk penggunaan server.Anda dapat menggunakan wadah ini untuk menyimpan objek yang ingin Anda kloning dan orangtua ke ruang kerja atau kontainer lain saat menjalankan.Sebagai contoh, Anda dapat menyimpan objek besar seperti peta di kontainer ini sampai mereka dibutuhkan dan memindahkannya ke ruang kerja hanya ketika diperlukan Ini memungkinkan Anda mengurangi lalu lintas jaringan klien saat bergabung awal.
Skrip tidak dijalankan saat mereka diparentkan ke wadah ini, tetapi skrip di dalam [ServerScriptService](/docs/id-id/reference/engine/classes/ServerScriptService) dapat mengakses dan menjalankan objek [ModuleScript](/docs/id-id/reference/engine/classes/ModuleScript) di wadah ini.
### [Pelanggan](#pelanggan)
Layanan kontainer klien dimaksudkan untuk objek yang direplikasi ke setiap klien yang terhubung.Kategori kontainer ini direplikasi ke setiap klien terhubung dan biasanya berisi objek 3D dan objek terkait [LocalScript](/docs/id-id/reference/engine/classes/LocalScript).Semua objek yang Anda simpan di kontainer ini tidak bertahan selama sesi dan diatur ulang setiap kali klien bergabung kembali.Anda dapat menempatkan objek di kontainer ini seperti antarmuka pengguna pemain, skrip sisi klien, dan objek lain yang hanya relevan dengan klien.
Ketika klien terhubung ke server, layanan kontainer [Players](/docs/id-id/reference/engine/classes/Players) mendengarkan penggabungan pengguna ke tempat Anda dan membuat objek [Player](/docs/id-id/reference/engine/classes/Player) untuk setiap klien.Server menyalin objek dari kontainer klien dalam model data edit ke lokasi yang sesuai dalam model data runtime di dalam objek [Players](/docs/id-id/reference/engine/classes/Players).Tabel berikut menjelaskan wadah asli tempatnya berada di dalam kontainer dan wadah hasil yang disalin ke klien:
| Edit model data | Model data waktu nyata | Catatan |
| --- | --- | --- |
| [StarterPack](/docs/id-id/reference/engine/classes/StarterPack) | Pemain.Backpack | Skrip yang mengatur inventaris pemain dan umumnya berisi [Tool](/docs/id-id/reference/engine/classes/Tool) objek tetapi sering juga berisi skrip lokal. |
| [StarterGui](/docs/id-id/reference/engine/classes/StarterGui) | Pemain.PlayerGui | Skrip yang dapat mengelola GUI lokal pemain.Ketika pemain muncul kembali, konten PlayerGui dihapus.Server menyalin objek di dalam StarterGui ke PlayerGui. |
| [StarterPlayerScripts](/docs/id-id/reference/engine/classes/StarterPlayerScripts) | Skrip Pemain.Player | Skrip tujuan umum untuk klien.Sebagai contoh, jika Anda ingin membuat efek khusus pada klien saat kondisi tertentu dipenuhi, Anda dapat menempatkan skrip lokal di kontainer ini untuk melakukan itu.Server tidak dapat mengakses kontainer ini. |
| [StarterCharacterScripts](/docs/id-id/reference/engine/classes/StarterCharacterScripts) | Pemain.Karakter | Skrip yang disalin ke klien saat mereka muncul. Skrip ini tidak bertahan ketika pemain bereinkarnasi. |
| [ReplicatedFirst](/docs/id-id/reference/engine/classes/ReplicatedFirst) | | Konten dari wadah ini dipindahkan ke semua klien (tetapi tidak kembali ke server) terlebih dahulu, sebelum hal lain. |
Untuk informasi lebih lanjut tentang model data edit dan runtime, lihat [runtime klien\-server](/docs/id-id/projects/client-server#client).
Anda tidak menambahkan objek [Player](/docs/id-id/reference/engine/classes/Player) ke layanan kontainer [Players](/docs/id-id/reference/engine/classes/Players) secara eksplisit.
### [chat](#chat)
#### Layanan Obrolan Teks
[TextChatService](/docs/id-id/reference/engine/classes/TextChatService) mewakili layanan yang menangani berbagai tugas obrolan teks dalam pengalaman, seperti mengelola saluran, menghias pesan, menyaring teks, membuat perintah, dan mengembangkan antarmuka obrolan khusus.
Untuk informasi lebih lanjut, lihat [Sistem obrolan teks dalam pengalaman](/docs/id-id/chat/in-experience-text-chat).
#### Layanan Obrolan Suara
[VoiceChatService](/docs/id-id/reference/engine/classes/VoiceChatService) mewakili fitur obrolan suara berbasis jarak yang meniru komunikasi realistis berdasarkan seberapa dekat Anda dengan pengguna lain.Anda dapat menggunakan layanan ini untuk menyalakan dan mematikan fitur.
Untuk informasi lebih lanjut, lihat [Obrolan suara](/docs/id-id/chat/voice-chat).
## [Folder dan model](#folder-dan-model)
Ada dua metode utama untuk menggrupkan objek dalam model data: folder dan model .Keduanya adalah kontainer untuk objek, tetapi mereka memiliki tujuan yang berbeda.
* Folder adalah yang terbaik untuk menyimpan bagian dari lingkungan, seperti lobi atau arena pertempuran.
* Model digunakan untuk serangkaian objek, seperti set meja yang memiliki kursi, meja, dan lampu.Untuk mengatur set yang lebih kompleks, kelompokkan model di dalam model.
Anda harus selalu menamai objek Anda secara deskriptif. Ini memudahkan untuk menemukan dan memodifikasi objek nanti jika diperlukan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Example-Organized-Folders-In-Workspace.png' alt='The Explorer window with a demonstration of a folder organization structure.' title='' width='320' height='' />
*Objek diatur menjadi [Folders](/docs/id-id/reference/engine/classes/Folder)*
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Example-Maps-In-Workspace-ServerStorage.png' alt='The Explorer window with a demonstration of a model organization structure in several services.' title='' width='320' height='' />
*Berbagai model "peta" untuk bertukar antara [Workspace](/docs/id-id/reference/engine/classes/Workspace) dan [ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage)*
| 78 |
https://create.roblox.com/docs/id-id/projects/client-server
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
6. /
7. [Arsitektur](/docs/id-id/projects/data-model)
Bahasa Indonesia
Masukan
# Waktu eksekusi klien\-server
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/client-server).
## [Pelayan](#pelayan)
Pengalaman Roblox adalah multi\-pemain secara default dan dijalankan dalam model klien\-server.Server Roblox adalah otoritas terakhir untuk menjaga kondisi pengalaman, dan bertanggung jawab untuk menjaga semua klien terhubung sinkron dengan server .
<img src='https://prod.docsiteassets.roblox.com/assets/scripting/client-server/Client-Server-Model.png' alt='A server grouping with connections to three client devices.' title='' width='100%' height='' />
*Server dengan koneksi ke tiga perangkat klien*
## [Pelanggan](#pelanggan)
Saat pengalaman dijalankan, Roblox menyalin versi model data "edit" yang Anda buat dan publikasikan dari Studio dan menjalankannya di server Roblox sebagai model data " runtime ".
Klien terhubung juga menerima salinan model data runtime dan setiap inisialisasi pemain terjadi, seperti menginisialisasi ransel pemain (inventaris) atau antarmuka pengguna lokal.Ketika pengalaman memiliki [Workspace.StreamingEnabled](/docs/id-id/reference/engine/classes/Workspace#StreamingEnabled) diatur ke benar, server awalnya hanya mengirim subset konten di bawah [Workspace](/docs/id-id/reference/engine/classes/Workspace) yang paling dekat dengan klien.Klien kemudian menampilkan dunia 3D dan mulai menjalankan skrip yang berlaku.
<img src='https://prod.docsiteassets.roblox.com/assets/scripting/client-server/Data-Model-Mapping.png' alt='A diagram that maps objects between 'edit' and 'runtime' data models.' title='' width='720' height='' />
## [Replikasi](#replikasi)
Server terus memperbarui klien yang terhubung, menjaga semuanya sinkron di seluruh server dan klien melalui proses yang disebut replikasi , yang menyinkronkan model data, simulasi fisika, dan pesan obrolan.Logik replikasi ada di klien dan server untuk memastikan sinkronisasi.
### [Data](#data)
Perubahan model data dapat terjadi dalam berbagai kasus, seperti ketika sesuatu di dunia 3D dibuat atau perubahan properti dunia 3D.Ini biasanya terjadi ketika skrip di server atau klien membuat perubahan yang perlu dicerminkan di sisi lain batas klien\-server.Diagram berikut menunjukkan skenario umum untuk replikasi data.
Klien → Server \><img src='https://prod.docsiteassets.roblox.com/assets/scripting/client-server/Remote-Flow-Client-Server.png' alt='A diagram of one client communicating with the server.' title='' width='100%' height='' />Komunikasi dari klien ke server.Sebagai contoh, klien menekan tombol P untuk minum ramuan tembus pandang, dan memberi tahu server untuk membuat karakter pemain itu tidak terlihat untuk semua pemain lain.
Server → Klien \><img src='https://prod.docsiteassets.roblox.com/assets/scripting/client-server/Remote-Flow-Server-Client.png' alt='A diagram of the server communicating with one client.' title='' width='100%' height='' />Komunikasi dari server ke satu klien tertentu.Sebagai contoh, seorang pemain bergabung dengan pengalaman dan server mengisi inventaris pemain itu dengan serangkaian item.
Server → Semua Klien \><img src='https://prod.docsiteassets.roblox.com/assets/scripting/client-server/Remote-Flow-Server-All-Clients.png' alt='A diagram of the server communicating with all connected clients.' title='' width='100%' height='' />Komunikasi antara server dan semua klien terhubung.Sebagai contoh, menampilkan waktu mundur ke semua peserta dalam sebuah balapan.
### [Fisika](#fisika)
Roblox menggunakan mesin fisika tubuh kaku, yang bertanggung jawab untuk menghitung gerakan dan interaksi bagian di dunia 3D.Secara default, semua bagian di Roblox adalah tubuh kaku dan berpartisipasi dalam fisika simulasi, kecuali dinyatakan lain.Anda juga dapat menggrupkan beberapa bagian bersama\-sama menjadi kumpulan, yang ditangani oleh mesin fisika sebagai tubuh tunggal yang kaku.
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Block.png' alt='A single block part in the shape of a cube that represents a single assembly.' title='' width='100%' height='' />
*1 pengumpulan; 1 bagian*
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Avatar.png' alt='A player character that represents a single assembly of 18 individual parts.' title='' width='100%' height='' />
*1 assemblasi; 18 bagian*
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Ship.png' alt='A pirate ship mesh that represents a single assembly of 179 individual parts.' title='' width='100%' height='' />
*1 pengumpulan; 179 bagian*
Roblox mereplikasi data simulasi fisika antara server dan klien saat diperlukan.Untuk membantu kinerja simulasi, Roblox dapat menugaskan kepemilikan assemblies ke klien atau server tertentu.Ini berarti bahwa klien atau server dapat bertanggung jawab untuk menyimulasikan fisika dari kumpulan itu.Klien lain menerima pembaruan tentang posisi dan gerakan kumpulan dari klien atau server pemilik.Kepemilikan biasanya terjadi secara otomatis, tetapi Anda dapat menugaskannya secara langsung untuk responsibilitas yang disesuaikan.
[https://prod.docsiteassets.roblox.com/assets/physics/network-ownership/Visualization-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/network-ownership/Visualization-Demo.mp4)
*Kepemilikan bagian ditunjukkan melalui garis berwarna*
### [chat](#chat)
Roblox menyalin pesan obrolan antara server dan klien.Server bertanggung jawab untuk menyaring pesan obrolan dan memutuskan pesan mana yang harus direplikasikan ke klien lain.Sebagai contoh, server dapat menyaring pesan yang berisi kata\-kata kotor atau terlalu panjang.
[https://prod.docsiteassets.roblox.com/assets/players/in-experience-text-chat/Player-Conversation-Bubbles.mp4](https://prod.docsiteassets.roblox.com/assets/players/in-experience-text-chat/Player-Conversation-Bubbles.mp4)
| 79 |
https://create.roblox.com/docs/id-id/workspace/streaming
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
6. /
7. [Arsitektur](/docs/id-id/projects/data-model)
Bahasa Indonesia
Masukan
# Streaming instansi
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/workspace/streaming).
Pengalaman dalam streaming instan memungkinkan Roblox Engine untuk secara dinamis memuat dan melepaskan konten 3D dan instans terkait di wilayah dunia.Ini dapat meningkatkan pengalaman pemain secara keseluruhan dalam beberapa cara, misalnya:
* Waktu bergabung lebih cepat — Pemain dapat mulai bermain di satu bagian dunia sementara lebih banyak dunia dimuat di latar belakang.
* Efisiensi memori — Pengalaman dapat dimainkan di perangkat dengan memori lebih sedikit karena konten diputar secara dinamis masuk dan keluar.Dunia yang lebih imersif dan terperinci dapat dimainkan pada rentang perangkat yang lebih luas.
* Peningkatan kinerja — Tingkat frame dan pelaksanaanyang lebih baik, karena server dapat menghabiskan lebih sedikit waktu dan bandwidth untuk menyinkronkan perubahan antara dunia dan pemain di dalamnya.Klien menghabiskan lebih sedikit waktu untuk memperbarui instansi yang saat ini tidak relevan dengan pemain.
* Tingkat rincian — Model jauh dan medan tetap terlihat bahkan ketika tidak diputar ke klien, menjaga pengalaman dioptimalkan tanpa sepenuhnya mengorbankan visual latar belakang.
## [Aktifkan streaming](#aktifkan-streaming)
streaming instansi diaktifkan melalui properti StreamingEnabled dari objek Ruang kerja di Studio.Properti ini tidak dapat ditetapkan dalam skrip.Streaming diaktifkan secara default untuk tempat baru yang dibuat di Studio.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Workspace-StreamingEnabled.png' alt='The Properties window with the StreamingEnabled property enabled.' title='' width='320' height='' />Setelah diaktifkan, disarankan agar Anda mematuhi praktik berikut:
* Karena klien biasanya tidak akan memiliki seluruh [Workspace](/docs/id-id/reference/engine/classes/Workspace) tersedia secara lokal, gunakan alat/API yang tepat untuk memastikan instans ada sebelum mencoba mengaksesnya di [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) .Sebagai contoh, gunakan [kontrol streaming per model](#per-model-streaming-controls) , [mendeteksi streaming instansi](#detect-instance-streaming) , atau gunakan [WaitForChild()](/docs/id-id/reference/engine/classes/Instance#WaitForChild) pada objek yang mungkin tidak ada.
* Minimalkan penempatan konten 3D di luar [Workspace](/docs/id-id/reference/engine/classes/Workspace) .Konten di kontainer seperti [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) atau [ReplicatedFirst](/docs/id-id/reference/engine/classes/ReplicatedFirst) tidak memenuhi syarat untuk streaming dan dapat mempengaruhi waktu bergabung dan penggunaan memori secara negatif.
* Jika Anda memindahkan karakter pemain dengan menetapkan [CFrame](/docs/id-id/reference/engine/datatypes/CFrame) , lakukan dari sisi server [Script](/docs/id-id/reference/engine/classes/Script) dan gunakan [permintaan streaming](#request-area-streaming) untuk lebih cepat memuat data di sekitar lokasi baru karakter.
* Secara manual atur pemainnya [ReplicationFocus](/docs/id-id/reference/engine/classes/Player#ReplicationFocus) hanya dalam situasi unik seperti dalam pengalaman yang tidak menggunakan [Player.Character](/docs/id-id/reference/engine/classes/Player#Character) .Dalam kasus ini, pastikan fokusnya dekat dengan objek(s) yang dikendalikan pemain untuk memastikan konten terus diputar di sekitar titik interaksi pemain.
## [Perilaku teknis](#perilaku-teknis)
### [Siarkan di](#siarkan-di)
Secara default, ketika pemain bergabung dengan pengalaman dengan streaming instansi diaktifkan, instans di [Workspace](/docs/id-id/reference/engine/classes/Workspace) dikirimkan ke klien, mengecualikan mengikuti:
* [Parts](/docs/id-id/reference/engine/classes/Part) or [MeshParts](/docs/id-id/reference/engine/classes/MeshPart)
* [Atomik](#atomic) , [Persisten](#persistent) , atau [PersistenPerPemain](#persistentperplayer) model
* Keturunan dari instansi di atas
* Instansi tidak bereplikasi
Kemudian, selama gameplay, server dapat menyiarkan instans yang diperlukan ke klien, karena diperlukan.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/streaming/Technical-Behavior.svg' alt='Diagram showing when various instances and their descendants in the Workspace stream in.' title='' width='800' height='464' />
*1 Tanah diperlakukan secara unik, di mana instansi direplikasi ke klien saat pengalaman dimuat, tetapi wilayah tanah hanya diputar saat diperlukan*
#### Perilaku model
Model ditetapkan ke perilaku non\-default seperti [Atomic](#atomic) aliran di bawah aturan khusus seperti yang dijelaskan di [kontrol streaming per model](#per-model-streaming-controls).Namun, model default (nonatomi) dikirim berbeda tergantung pada apakah [ModelStreamingBehavior](#modelstreamingbehavior) diatur ke Default ( Legacy ) atau Ditingkatkan .
Standar / Legasi
Ditingkatkan
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Workspace-ModelStreamingBehavior-Default.png' alt='The Properties window with the ModelStreamingBehavior property set to Default.' title='' width='320' height='121' />Ketika [ModelStreamingBehavior](#modelstreamingbehavior) diatur ke Default / Legacy , wadah [Model](/docs/id-id/reference/engine/classes/Model) dan keturunann non\-spasialnya seperti [Scripts](/docs/id-id/reference/engine/classes/Script) di replikasikan ke klien saat pemain bergabung.Kemudian, ketika memenuhi syarat, keturunan model [BasePart](/docs/id-id/reference/engine/classes/BasePart) turun.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/streaming/Model-Stream-In-Default.svg' alt='Diagram showing default model stream in behavior.' title='' width='800' height='176' />
### [Siarkan keluar](#siarkan-keluar)
Selama gameplay, klien dapat menyiarkan keluar (hapus dari wilayah pemain [Workspace](/docs/id-id/reference/engine/classes/Workspace) ) dan [BaseParts](/docs/id-id/reference/engine/classes/BasePart) yang terkandung di dalamnya, berdasarkan perilaku yang ditetapkan oleh [StreamOutBehavior](#streamoutbehavior) .Proses dimulai dengan wilayah terjauh dari karakter pemain (atau [ReplicationFocus](/docs/id-id/reference/engine/classes/Player#ReplicationFocus) ) dan bergerak lebih dekat sebagaimana diperlukan.Wilayah di dalam rentang [StreamingMinRadius](#streamingminradius) tidak pernah diputar keluar.
Ketika instansi diputar keluar, ia diasosiasikan ke nil sehingga setiap negara Luau yang ada akan terhubung kembali jika instansi diputar kembali.Sebagai hasilnya, menghapus sinyal seperti [ChildRemoved](/docs/id-id/reference/engine/classes/Instance#ChildRemoved) atau [DescendantRemoving](/docs/id-id/reference/engine/classes/Instance#DescendantRemoving) api pada orang tuanya atau leluhur , tetapi instans itu sendiri tidak hancur dengan cara yang sama seperti panggilan [Instance:Destroy()](/docs/id-id/reference/engine/classes/Instance#Destroy).
Untuk lebih memperkirakan aliran keluar, periksa skenario ini:
| Skenario | Contoh | Perilaku siaran |
| --- | --- | --- |
| Suku bagian adalah dibuat secara lokal melalui [Instance.new()](/docs/id-id/reference/engine/classes/Instance#new) di dalam [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) . | Dalam game"tangkap bendera", Anda membuat dan menempelkan bagian helm biru ke semua pemain di tim biru melalui [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) . | Bagian tidak direplikasi ke server, dan dikecualikan dari streaming keluar kecuali Anda menjadikannya keturunan dari bagian yang ada di server, seperti bagian dalam model karakter pemain. |
| Suku cadang diklon lokal dari \*\*\*\* melalui [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) di [Instance:Clone()](/docs/id-id/reference/engine/classes/Instance#Clone) dalam [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) . | Karakter penyihir melemparkan mantra dengan mengaktifkan [Tool](/docs/id-id/reference/engine/classes/Tool), di mana objek termasuk beberapa [efek khusus](/docs/id-id/environment#special-effects) di\-kloning dari [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) dan dipindahkan ke ruang kerja di posisi penyihir. | Bagian tidak direplikasi ke server, dan dikecualikan dari streaming keluar kecuali Anda menjadikannya turunan dari bagian yang ada di server. |
| Bagian adalah diperbaiki dari [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) ke ruang kerja melalui [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) . | Topi "penyihir" disimpan di [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) .Ketika seorang pemain memilih untuk bermain di tim penyihir, topi dipindahkan ke model karakter mereka melalui [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) . | Bagian tetap memenuhi syarat untuk diputar karena berasal dari server dan direplikasi ke [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) .Hindari pola ini karena menyebabkan desinkronisasi antara klien dan server, dan bagiannya dapat diputar; sebagai gantinya, klon bagiannya. |
#### Perilaku model
Jika Anda mengatur [ModelStreamingBehavior](#modelstreamingbehavior) ke Ditingkatkan , mesin dapat menyiarkan model [Default](#default--nonatomic) ( [Nonatomi](#default--nonatomic) ) ketika mereka memenuhi syarat untuk diputar, mungkin membebaskan memori di klien dan mengurangi instansi yang membutuhkan pembaruan properti.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Workspace-ModelStreamingBehavior-Improved.png' alt='The Properties window with the ModelStreamingBehavior property set to Improved.' title='' width='320' height='' />Di bawah ditingkatkan model streaming perilaku, streaming keluar dari Default ( Nonatomik ) model berdasarkan apakah model tersebut adalah spasial (berisi keturunan) atau non\-spasial (tidak berisi keturunan ).
* Model spasial hanya diputar sepenuhnya ketika descendant terakhirnya [BasePart](/docs/id-id/reference/engine/classes/BasePart) keluar, karena beberapa bagian spasial model mungkin berada dekat dengan fokus pemain/replikasi dan beberapa jauh.
* Model non\-spasial hanya diputar keluar saat leluhur diputar keluar, setara dengan perilaku streaming lama keluar.
### [Kumpulan dan mekanisme](#kumpulan-dan-mekanisme)
Ketika setidaknya satu bagian dari [kumpulan](/docs/id-id/physics/assemblies) adalah memenuhi syarat untuk streaming, semua bagian kumpulan juga diputar.Namun, sebuah assemblasi tidak akan menyiarkan keluar sampai semua bagiannya memenuhi syarat untuk diputar keluar.Selama streaming, semua [Constraints](/docs/id-id/reference/engine/classes/Constraint) dan [Attachments](/docs/id-id/reference/engine/classes/Attachment) turun dari [BaseParts](/docs/id-id/reference/engine/classes/BasePart) dan atomik atau permanen [Models](/docs/id-id/reference/engine/classes/Model) juga streaming, membantu untuk memastikan pembaruan fisika konsisten pada klien.
Perhatikan bahwa kumpulan dengan bagian diikat diperlakukan sedikit berbeda dari kumpulan hanya dengan bagian yang tidak diikat:
| Komposisi pengumpulan | Perilaku siaran |
| --- | --- |
| Bagian yang tidak diikat hanya | Seluruh assemblasi dikirim sebagai unit atomik. |
| Tertahan [bagian akar](/docs/id-id/physics/assemblies#assembly-root-part) | Hanya bagian, lampiran, dan batasan yang diperlukan untuk menautkan bagian yang diputar ke bagian akar disiarkan bersama\-sama. |
Hindari membuat kumpulan bergerak dengan jumlah instans yang tidak perlu besar, karena semua instans yang streaming secara bersamaan dapat menyebabkan lonjakan jaringan/CPU.
### [Penundaan waktu](#penundaan-waktu)
Mungkin ada sedikit kelambatan \~10 milidetik antara ketika bagian dibuat di server dan ketika di\-复制 ke klien.Dalam setiap skenario berikut, Anda mungkin perlu menggunakan [WaitForChild()](/docs/id-id/reference/engine/classes/Instance#WaitForChild) dan teknik lain daripada menganggap bahwa peristiwa dan pembaruan properti selalu terjadi pada saat yang sama sebagai bagian streaming.
| Skenario | Contoh | Perilaku siaran |
| --- | --- | --- |
| A [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) membuat panggilan [RemoteFunction](/docs/id-id/reference/engine/classes/RemoteFunction) ke server untuk membuat bagian | Seorang pemain mengaktifkan [Tool](/docs/id-id/reference/engine/classes/Tool) lokal untuk menypawn bagian di server yang dapat dilihat dan berinteraksi dengan semua pemain. | Ketika fungsi remote kembali ke klien, bagian mungkin belum ada, meskipun bagian berada dekat dengan fokus klien dan dalam area yang disiarkan. |
| Bagian ditambahkan ke model karakter di server melalui [Script](/docs/id-id/reference/engine/classes/Script) dan [RemoteEvent](/docs/id-id/reference/engine/classes/RemoteEvent) ditembak ke klien. | Ketika seorang pemain bergabung dengan tim polisi, bagian "lencana polisi" yang disimpan di [ServerStorage](/docs/id-id/reference/engine/classes/ServerStorage) diklon dan ditambahkan ke model karakter pemain.A [RemoteEvent](/docs/id-id/reference/engine/classes/RemoteEvent) ditembak dan diterima oleh klien pemain itu untuk memperbarui elemen UI lokal. | Meskipun klien menerima sinyal acara, tidak ada jaminan bahwa bagian sudah diputar ke klien itu. |
| Suku bagian bertabrakan dengan wilayah tak terlihat di server dan memicu [RemoteEvent](/docs/id-id/reference/engine/classes/RemoteEvent) pada klien. | Seorang pemain menendang bola sepak ke gawang, memicu acara "goal dicetak" | Pemain lain yang dekat dengan gol mungkin melihat acara "goal dicetak" sebelum bola telah disiarkan kepada mereka. |
## [Properti siaran streaming](#properti-siaran-streaming)
Properti berikut mengontrol bagaimana streaming instansi berlaku untuk pengalaman Anda.Semua properti ini adalah tidak dapat diskripkan dan harus diatur pada objek Ruang kerja di Studio.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Workspace-Streaming-Properties.png' alt='The Properties window with the ModelStreamingBehavior, StreamingIntegrityMode, StreamingMidRadius, StreamingTargetRadius, and StreamOutBehavior property highlighted.' title='' width='320' height='' />
### [Perilaku Pemutaran Model](#perilaku-pemutaran-model)
Mengontrol apakah [Default](#default--nonatomic) ( [Nonatomi](#default--nonatomic) ) model direplikasi saat pemain bergabung, atau hanya dikirim saat diperlukan.Jika properti ini diatur ke Ditingkatkan , model di [Workspace](/docs/id-id/reference/engine/classes/Workspace) hanya akan dikirim ke klien saat diperlukan, yang berpotensi mempercepat waktu bergabung.Lihat [Perilaku Teknis](#technical-behavior) untuk lebih banyak rincian.
### [Mode Integritas Streaming](#mode-integritas-streaming)
Pengalaman Anda dapat berperilaku dengan cara yang tidak disengaja jika pemain pindah ke wilayah dunia yang belum disiarkan kepada mereka.Fitur integritas streaming menawarkan cara untuk menghindari situasi berpotensi bermasalah tersebut.Silakan lihat dokumentasi [Enum.StreamingIntegrityMode](/docs/id-id/reference/engine/enums/StreamingIntegrityMode) untuk lebih banyak rincian.
### [StreamingMinRadius](#streamingminradius)
Properti StreamingMinRadius menunjukkan radius di sekitar karakter pemain (atau [ReplicationFocus](/docs/id-id/reference/engine/classes/Player#ReplicationFocus) ) di mana streaming terjadi dengan prioritas tertinggi.Perawatan harus diambil saat meningkatkan default, karena melakukannya akan membutuhkan lebih banyak memori dan lebih banyak bandwidth server dengan biaya komponen lain.
### [StreamingTargetRadius](#streamingtargetradius)
Properti StreamingTargetRadius mengontrol jarak maksimum dari karakter pemain (atau [ReplicationFocus](/docs/id-id/reference/engine/classes/Player#ReplicationFocus) ) di mana streaming terjadi.Perhatikan bahwa mesin diizinkan untuk menyimpan instansi yang sebelumnya dimuat di luar radius target, memungkinkan memori.
Sebuah radius target streaming yang lebih kecil StreamingTargetRadius mengurangi beban server, karena server tidak akan menyiarkan di instans tambahan di luar nilai yang ditetapkan.Namun, radius target juga merupakan jarak maksimum yang akan dapat dilihat pemain untuk melihat seluruh rincian pengalaman Anda, jadi Anda harus memilih nilai yang menciptakan keseimbangan yang bagus di antara keduanya.
StreamingTargetRadius harus lebih besar dari StreamingMinRadius .Konten 3D antara radius target dan radius minimum bertindak sebagai penyangga jika klien sementara berhenti menerima konten baru dari server.Ketika radius minimum dan radius target sama, tidak ada penyangga, yang dapat menyebabkan peningkatan jeda jaringan atau pengalaman pengguna yang kurang optimal.
### [Perilaku StreamKeluar](#perilaku-streamkeluar)
Properti StreamOutBehavior menetapkan perilaku [streaming keluar](#stream-out) sesuai dengan salah satu nilai berikut:
| Pengaturan | Perilaku siaran |
| --- | --- |
| Standar | Perilaku default, saat ini sama dengan LowMemory . |
| Memori Rendah | Klien hanya menyiarkan bagian dalam situasi memori rendah dan dapat menghapus konten 3D sampai hanya radius minimum hadir. |
| Beruntungan | Wilayah di luar [StreamingTargetRadius](#streamingtargetradius) dapat dihapus pada klien bahkan ketika tidak ada tekanan memori.Dalam mode ini, klien tidak pernah menghapus instansi yang lebih dekat dari radius target, kecuali dalam situasi memori rendah. |
## [kendalisiaran per model](#kendalisiaran-per-model)
Secara global, properti [ModelStreamingBehavior](#modelstreamingbehavior) memungkinkan Anda mengontrol bagaimana model diputar saat bergabung.Selain itu, untuk menghindari masalah dengan streaming pada basis per model dan meminimalisir penggunaan [WaitForChild()](/docs/id-id/reference/engine/classes/Instance#WaitForChild) , Anda dapat menyesuaikan bagaimana [Models](/docs/id-id/reference/engine/classes/Model) dan keturunan mereka menyiarkan melalui properti [ModelStreamingMode](/docs/id-id/reference/engine/classes/Model#ModelStreamingMode) mereka.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Model-ModelStreamingMode.png' alt='The Properties window with the ModelStreamingMode property set to Default. The property is also highlighted.' title='' width='320' height='' />
### [Standar / nonatomiik](#standar--nonatomiik)
Ketika sebuah [Model](/docs/id-id/reference/engine/classes/Model) diatur ke Default atau Nonaktif , perilaku streaming bervariasi tergantung pada apakah [ModelStreamingBehavior](#modelstreamingbehavior) diatur ke Default ( Legacy ) atau Ditingkatkan .
| [Perilaku Pemutaran Model](#modelstreamingbehavior) | Perilaku teknis |
| --- | --- |
| Dasar ( Warisan ) | Model diulang ketika pemain bergabung.Ini berpotensi menghasilkan lebih banyak instans yang dikirim selama pemuatan, lebih banyak instans yang disimpan di memori, dan kompleksitas tambahan untuk skrip yang ingin mengakses keturunan model.Sebagai contoh, terpisah [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) akan perlu menggunakan [WaitForChild()](/docs/id-id/reference/engine/classes/Instance#WaitForChild) pada keturunan [BasePart](/docs/id-id/reference/engine/classes/BasePart) di dalam model. |
| Ditingkatkan | Model hanya dikirim saat diperlukan, yang berpotensi mempercepat waktu bergabung. |
Lihat [perilaku teknis](#technical-behavior) untuk lebih banyak detail.
### [Atomik](#atomik)
Jika [Model](/docs/id-id/reference/engine/classes/Model) diubah menjadi Atomik , semua keturunannya diputar bersama ketika keturunan [BasePart](/docs/id-id/reference/engine/classes/BasePart) memenuhi syarat.Sebagai hasilnya, terpisah [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) yang perlu mengakses instansi dalam model perlu menggunakan [WaitForChild()](/docs/id-id/reference/engine/classes/Instance#WaitForChild) pada model itu sendiri, tetapi tidak pada keturunan [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) atau [Part](/docs/id-id/reference/engine/classes/Part) karena mereka dikirim bersama model.
Model atom hanya diputar keluar ketika semua bagian turunannya memenuhi syarat untuk diputar, pada saat itu seluruh model diputar bersama\-sama.Jika hanya beberapa bagian dari model atomik yang biasanya akan diputar keluar, seluruh model dan keturunannnya tetap ada di klien.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/streaming/ModelStreamingMode-Atomic.svg' alt='A diagram showing Atomic model streaming along with children.' title='' width='800' height='336' />
```
Skrip Lokal
---
```
local Workspace = game:GetService("Workspace")
-- Model atom tidak ada saat dimuat; gunakan WaitForChild()
local model = Workspace:WaitForChild("Model")
-- Bagian keturunan mengalir bersama model dan segera dapat diakses
local meshPart = model.MeshPart
local part = model.Part
```
```
### [Bertahan](#bertahan)
Model bertahan tidak terkena streaming normal masuk atau keluar.Mereka dikirim sebagai unit atom lengkap segera setelah pemain bergabung dan sebelum peristiwa [Workspace.PersistentLoaded](/docs/id-id/reference/engine/classes/Workspace#PersistentLoaded) terjadi.Model permanen dan keturunannya tidak pernah diputar, tetapi untuk menangani streaming dengan aman di dalam model orangtua terpisah [LocalScript](/docs/id-id/reference/engine/classes/LocalScript), Anda harus menggunakan [WaitForChild()](/docs/id-id/reference/engine/classes/Instance#WaitForChild) pada model orangtua, atau menunggu acara [PersistentLoaded](/docs/id-id/reference/engine/classes/Workspace#PersistentLoaded) terjadi.
<img src='https://prod.docsiteassets.roblox.com/assets/optimization/streaming/ModelStreamingMode-Persistent.svg' alt='A diagram showing Persistent model streaming along with children.' title='' width='800' height='336' />
```
Skrip Lokal
---
```
local Workspace = game:GetService("Workspace")
-- Model permanen tidak ada saat dimuat; gunakan WaitForChild()
local model = Workspace:WaitForChild("Model")
-- Bagian keturunan mengalir bersama model dan segera dapat diakses
local meshPart = model.MeshPart
local part = model.Part
```
```
Model permanen dimaksudkan untuk situasi yang sangat langka, seperti ketika jumlah bagian kecil harus selalu hadir pada klien untuk penggunaan [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) .Jika memungkinkan, sisi server [Scripts](/docs/id-id/reference/engine/classes/Script) harus digunakan, atau [LocalScripts](/docs/id-id/reference/engine/classes/LocalScript) harus toleran terhadap bagian streaming masuk dan keluar.Model permanen bukan tidak dimaksudkan untuk menghindari streaming, dan penyalahgunaan berlebih dapat mempengaruhi pelaksanaansecara negatif.
Hindari membuat model permanen all\-catch yang memiliki banyak sub\-model.Sebagai contoh, jika Anda membuat pengalaman dengan jumlah besar kendaraan, lakukan tidak membuat model persisten tunggal yang berisi setiap kendaraan dalam pengalaman yang ingin Anda persisten.Sebagai gantinya, atur setiap model kendaraan individu untuk menjadi persisten, jika diperlukan.
Dampak kinerja waktu nyata dari model permanen setelah replicasi sebagian besar sama dengan model reguler tanpa streaming diaktifkan.Pengecualian adalah ketika konten model sering berubah atau jika bagian dalam model memiliki perubahan koneksi fisik.Dalam kasus ini, mesin harus melakukan pembaruan ekstra untuk memastikan perubahan tersebut dicerminkan dengan benar di semua klien, jadi yang terbaik adalah menghindari perubahan sering ke model permanen.
### [Pemain TetapPerPlayer](#pemain-tetapperplayer)
Model diatur ke PersistenPerPemain berperilaku sama dengan [Persisten](#persistent) untuk pemain yang telah ditambahkan menggunakan [Model:AddPersistentPlayer()](/docs/id-id/reference/engine/classes/Model#AddPersistentPlayer) .Untuk pemain lain, perilaku sama dengan [Atomik](#atomic).Anda dapat membalikkan model dari persistensi pemain melalui [Model:RemovePersistentPlayer()](/docs/id-id/reference/engine/classes/Model#RemovePersistentPlayer) .
## [Meminta streaming area](#meminta-streaming-area)
Jika Anda mengatur [CFrame](/docs/id-id/reference/engine/datatypes/CFrame) karakter pemain ke wilayah yang saat ini tidak dimuat, [jeda streaming](#customize-the-pause-screen) terjadi, jika diaktifkan.Jika Anda tahu karakter akan pindah ke area tertentu, Anda dapat menelepon [Player:RequestStreamAroundAsync()](/docs/id-id/reference/engine/classes/Player#RequestStreamAroundAsync) untuk meminta server mengirim wilayah di sekitar lokasi itu ke klien.
Skrip berikut menunjukkan cara menembakkan peristiwa jarak jauh klien ke server [untuk teleport pemain di dalam tempat](/docs/id-id/scripting/events/remote) ke streaming permintaan sebelum memindahkan karakter ke yang baru [CFrame](/docs/id-id/reference/engine/datatypes/CFrame).
```
Skrip - Teleport Karakter Pemain
---
```
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local teleportEvent = ReplicatedStorage:WaitForChild("TeleportEvent")
local function teleportPlayer(player, teleportTarget)
-- Permintaan streaming di sekitar lokasi target
player:RequestStreamAroundAsync(teleportTarget)
-- Karakter teleportasi
local character = player.Character
if character and character.Parent then
local currentPivot = character:GetPivot()
character:PivotTo(currentPivot * CFrame.new(teleportTarget))
end
end
-- Fungsi teleportasi panggilan saat klien menembakkan acara remote
teleportEvent.OnServerEvent:Connect(teleportPlayer)
```
```
```
Skrip Lokal - Acara Remote Api
---
```
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local teleportEvent = ReplicatedStorage:WaitForChild("TeleportEvent")
local teleportTarget = Vector3.new(50, 2, 120)
-- Tembak peristiwa remote
teleportEvent:FireServer(teleportTarget)
```
```
Meminta streaming di sekitar area adalah bukan jaminan bahwa konten akan hadir saat permintaan selesai, karena streaming dipengaruhi oleh bandwidth jaringan klien, batasan memori, dan faktor lain.
## [Deteksi streaming instansi](#deteksi-streaming-instansi)
Dalam beberapa kasus, diperlukan untuk mendeteksi kapan objek mengalir masuk atau keluar dan bereaksi terhadap peristiwa itu.Pola berguna untuk deteksi streaming adalah sebagai berikut:
1. Menggunakan bagian [Tag](/docs/id-id/studio/properties#instance-tags) dari properti kejadian, atau Editor Tag [Studio](/docs/id-id/studio/view-tab#windows-and-tools), atribusikan tag logis [CollectionService](/docs/id-id/reference/engine/classes/CollectionService) ke semua objek yang terpengaruh.
2. Dari satu [LocalScript](/docs/id-id/reference/engine/classes/LocalScript) , deteksi ketika objek ditagih mengalir masuk atau keluar melalui [GetInstanceAddedSignal()](/docs/id-id/reference/engine/classes/CollectionService#GetInstanceAddedSignal) dan [GetInstanceRemovedSignal()](/docs/id-id/reference/engine/classes/CollectionService#GetInstanceRemovedSignal) , lalu tangani objek sesuai dengan itu.Sebagai contoh, kode berikut menambahkan objek ber标签 [Light](/docs/id-id/reference/engine/classes/Light) ke dalam loop "flicker" saat mereka streaming masuk dan menghapusnya saat mereka streaming keluar.
```
Skrip Lokal - Pendeteksi Streaming Layanan Koleksi
---
```
local CollectionService = game:GetService("CollectionService")
local tagName = "FlickerLightSource"
local random = Random.new()
local flickerSources = {}
-- Deteksi saat ini dan bagian yang ditagih baru mengalir masuk atau keluar
for _, light in CollectionService:GetTagged(tagName) do
flickerSources[light] = true
end
CollectionService:GetInstanceAddedSignal(tagName):Connect(function(light)
flickerSources[light] = true
end)
CollectionService:GetInstanceRemovedSignal(tagName):Connect(function(light)
flickerSources[light] = nil
end)
-- Lingkaran flicker
while true do
for light in flickerSources do
light.Brightness = 8 + random:NextNumber(-0.4, 0.4)
end
task.wait(0.05)
end
```
```
## [Sesuaikan layar jeda](#sesuaikan-layar-jeda)
Properti [Player.GameplayPaused](/docs/id-id/reference/engine/classes/Player#GameplayPaused) menunjukkan status jeda saat ini pemain.Properti ini dapat digunakan dengan koneksi [GetPropertyChangedSignal()](/docs/id-id/reference/engine/classes/Instance#GetPropertyChangedSignal) untuk menampilkan atau menyembunyikan GUI khusus.
```
Skrip Lokal
---
```
local Players = game:GetService("Players")
local GuiService = game:GetService("GuiService")
local player = Players.LocalPlayer
-- Nonaktifkan modus jedak default
GuiService:SetGameplayPausedNotificationEnabled(false)
local function onPauseStateChanged()
if player.GameplayPaused then
-- Tampilkan GUI khusus
else
-- Sembunyikan GUI khusus
end
end
player:GetPropertyChangedSignal("GameplayPaused"):Connect(onPauseStateChanged)
```
```
## [Tingkat rincian model](#tingkat-rincian-model)
Ketika streaming diaktifkan, [Models](/docs/id-id/reference/engine/classes/Model) di luar area yang diputar saat ini tidak akan terlihat secara default.Namun, Anda dapat menginstruksikan mesin untuk menampilkan meshes "imposter" resolusi lebih rendah untuk model yang tidak hadir di klien melalui properti [LevelOfDetail](/docs/id-id/reference/engine/classes/Model#LevelOfDetail) setiap model.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Model-LevelOfDetail.png' alt='LevelOfDetail property indicated for Model instance' title='' width='320' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/model-objects/LevelOfDetail-Actual.jpg' alt='A globe model displays in its actual level of detail.' title='' width='100%' height='' />
*Model aktual*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/model-objects/LevelOfDetail-StreamingMesh.jpg' alt='The same globe model displays as a low resolution imposter mesh with rough edges that obscure the globe's details.' title='' width='100%' height='' />
*Jaring "impostor" resolusi rendah*
| Pengaturan model | Perilaku siaran |
| --- | --- |
| StreamingMesh | Aktifkan generasi asinkron dari mesh imposter untuk ditampilkan saat model tidak hadir di klien. |
| Dinonaktifkan / Otomatis | Model menghilang ketika berada di luar radius streaming. |
Saat menggunakan meshes imposter, perhatikan hal mengikuti:
* Imposter meshes dirancang untuk dilihat pada 1024 stud dari kamera atau lebih jauh.Jika Anda telah mengurangi [StreamingTargetRadius](#streamingtargetradius) ke nilai yang jauh lebih kecil seperti 256, meshes penipu mungkin tidak terlihat diterima untuk model yang digantikannya.
* Jika model dan model turunannya semua diatur ke StreamingMesh , hanya model leluhur tingkat atas yang ditampilkan sebagai mesh penipu, melapisi semua geometri di bawah leluhur serta model turunannya.Untuk kinerja yang lebih pelaksanaan, disarankan agar Anda menggunakan Dinonaktifkan untuk model turunan.
* Tekstur tidak didukung; meshes penipu dibuat sebagai meshes halus.
* Sementara [Model](/docs/id-id/reference/engine/classes/Model) tidak sepenuhnya disiarkan, mesh imposter dibuat sebagai gantinya bagian\-bagian individu dari model.Setelah semua bagian individual diputar, mereka menyajikan dan mesh penipu diabaikan.
* Imposter meshes tidak memiliki signifikansi fisik dan mereka bertindak sebagai tidak ada dalam hal [raycasting](/docs/id-id/workspace/raycasting) , [deteksi kolisi](/docs/id-id/workspace/collisions) , dan simulasi fisika.
* Mengedit model di Studio, seperti menambahkan/menghapus/menggeser ulang bagian anak atau mengatur ulang warna, secara otomatis memperbarui representasi mesh.
| 80 |
https://create.roblox.com/docs/id-id/projects/experience-ownership-transfer
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
6. /
7. [Kelola](/docs/id-id/production/publishing/publish-experiences-and-places)
Bahasa Indonesia
Masukan
# Pengalihan kepemilikan pengalaman
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/experience-ownership-transfer).
Dengan pengalihan kepemilikan pengalaman , Anda dapat mentransfer pengalaman Anda ke [kelompok](/docs/id-id/projects/groups) yang Anda miliki akses publiknya.Ini membuka semua fitur yang tersedia untuk kelompok, termasuk manajemen izin dan pendapatan, dan memungkinkan Anda untuk mengelola konten Anda secara efisien saat tim Anda berkembang dan prioritas Anda bergeser.
## [Prasyarat](#prasyarat)
Sebelum membuat transfer atau menerima transfer, Anda harus terlebih dahulu:
* Verifikasikan alamat email Anda.
* Upload pribadi Anda [ModuleScripts](/docs/id-id/reference/engine/classes/ModuleScript) ke grup yang Anda mentransfer pengalaman ke.Jika pengalaman menggunakan paket di mana pemilik paket adalah pengguna dan bukan kelompok, Anda mungkin harus membuat ulang paket tersebut atau menggantinya dengan paket yang sudah dimiliki oleh kelompok.
* Publikasikan aset animasi Anda ke grup yang Anda mentransfer pengalaman ke.
+ Jika Anda memiliki banyak animasi untuk upload, Anda dapat menggunakan alat pihak ketiga yang didukung komunitas seperti [Transfer Animasi Roblox](https://github.com/evaera/roblox-animation-transfer).Lihat [Animasi transfer](/docs/id-id/projects/transfer-animations) untuk lebih banyak detail.
+ Jika Anda memiliki sedikit animasi untuk diunggah, Anda dapat secara manual meng\-re uploadnya dan kemudian memperbarui referensi aset animasi Anda untuk mendukung ID lama dan baru berdasarkan CreatorID dan CreatorType.Lihat kode berikut untuk contoh:
```
---
```
-- ID animasi peta yang milik pencipta asli ke ID animasi
-- yang terkait dengan kreatorbaru.
local transferAnimationMap = {
["6406676108"] = 14292200298,
["6438293322"] = 14292082312,
["6464978998"] = 14292224322,
["6465240715"] = 14292226967,
["6465244287"] = 14292229476,
["6382318344"] = 14292213468,
["6382564692"] = 14292207171,
["6460651769"] = 14292098870,
["6415507655"] = 14292218236,
["6415509331"] = 14292221034
}
function mapTransferAnimationId(id)
-- Jika pengalaman telah dipindahkan, ID animasi lama diubah menjadi baru
if game:GetService("RunService"):IsStudio() or
(game.CreatorType == Enum.CreatorType.Group and
game.CreatorId == 32626384) then
local animationId = string.match(id, "%d+$")
local mappedId = transferAnimationMap[animationId]
if mappedId then
return "rbxassetid://" .. mappedId
end
end
return id
end
-- Membuat instansi animasi terkait dengan
-- ditentukan rbxassetid://<animation_id>
function createAnimation(id)
local animation = Instance.new("Animation")
animation.AnimationId = mapTransferAnimationId(id)
return animation
end
```
```
Sebagai praktik terbaik, jika Anda menggunakan kunci API Open Cloud untuk pengalaman, buat kunci API sebagai pemilik baru dengan nama RobloxTransferApiKey.Selama transfer, scope yang relevan ditambahkan ke kunci baru ini dan dihapus dari unitasli.Anda kemudian dapat menggunakan flag fitur untuk mengizinkan layanan backend Anda mulai menggunakan kunci baru setelah transfer selesai.
## [Transfer pengalaman](#transfer-pengalaman)
Untuk mentransfer pengalaman ke grup:
1. Pergi ke [Kreasi](https://create.roblox.com/dashboard/creations) dan pilih pengalaman yang ingin Anda transfer.
2. Pergi ke Konfigurasi ⟩ Pengaturan .
3. Klik Mulai transfer kepemilikan .
4. Di dialog Detail Transfer , baca dan akui dengan hati\-hati implikasi transfer. Kemudian, klik Berikutnya .
5. Pilih kelompok untuk mentransfer pengalaman ke kelompok ini. Anda harus dapat mempublikasikan pengalaman ke kelompok ini.
6. Verifikasikan transfer dengan memasukkan nama pengalaman.
7. Klik Mulai transfer . Halaman Pengaturan Konten diperbarui untuk menyertakan nama pengguna grup tertunda.
Setelah kelompok menerima transfer, Roblox membuat pengalaman Anda pribadi dan menutup semua server yang terkait dengannya.Proses transfer biasanya selesai dalam beberapa menit tetapi dapat memakan waktu lebih lama untuk pengalaman rumit.
Untuk membatalkan transfer tertunda, klik Batalkan permintaan transfer di halaman Pengaturan Konten .
## [Terima pengalaman yang dipindahkan](#terima-pengalaman-yang-dipindahkan)
Untuk menerima pengalaman yang dipindahkan:
1. Pergi ke halaman pengalaman dari pengalaman yang Anda terima.Anda dapat menavigasi ke halaman ini dengan mengklik pemberitahuan permintaan transfer yang Anda terima ketika pemilik saat ini pengalaman memulai transfer, atau dengan langsung mendapatkan tautan halaman ringkasan dari pemilik saat ini.
2. Di dialog Detail Transfer , baca dan akui dengan hati\-hati implikasi transfer. Kemudian, klik Berikutnya .
3. Verifikasikan transfer dengan memasukkan nama pengalaman.
4. Klik Terima transfer .
Setelah kelompok Anda menerima transfer, Roblox membuat pengalaman pribadi dan menutup semua server yang terkait dengannya.Proses transfer biasanya selesai dalam beberapa menit tetapi dapat memakan waktu lebih lama untuk pengalaman rumit.
5. Setelah transfer ke grup Anda selesai, atur izin baru yang Anda butuhkan dan buat pengalaman itu publik lagi.
## [Pertanyaan yang sering ditanyakan](#pertanyaan-yang-sering-ditanyakan)
Jenis informasi apa yang dipertahankan oleh pengalaman yang ditransfer?Pengalaman yang ditransfer mempertahankan ID pengalaman lama, ID tempat, dan URL.
Apakah permintaan transfer kedaluwarsa?Ya, permintaan transfer berakhir setelah 7 hari.
Seberapa sering pengalaman yang sama dapat ditransfer?Setelah menerima pengalaman yang dipindahkan, Anda harus menunggu 30 hari untuk mentransfer pengalaman itu lagi.
Dapatkah perubahan dilakukan pada pengalaman yang sedang mentransfer?Anda dapat terus membuat perubahan pada pengalaman sampai pemilik grup baru menerima transfer dan proses transfer dimulai.Perubahan yang Anda buat selama proses transfer aktif secara khusus tidak dipindahkan.
Apa yang terjadi pada informasi kartu kredit saat pengalaman dipindahkan?Roblox menghapus informasi kartu kredit saat Anda mentransfer pengalaman.
Apa yang terjadi pada pendapatan dari langganan server pribadi saat pengalaman dipindahkan?Kelompok yang Anda transfer pengalaman Anda ke menerima pendapatan dari langganan server pribadi yang ada.Pendapatan ini tidak menghormati pembagian pendapatan kelompok atau pengalaman.
Langganan server pribadi baru menghormati pembagian pendapatan.
Apakah mentransfer pengalaman mempengaruhi penemuan dampak?Mengirim pengalaman tidak memengaruhi pencarian selama judul pengalaman tetap sama, pemilik grup baru bukan akun yang dimoderasi, dan pengalaman dibuat publik lagi setelah transfer.
Perhatikan bahwa mentransfer pengalaman dapat mempengaruhi penemuan selama hingga 24 jam setelah pemilik grup baru membuat pengalaman itu publik lagi.
| 81 |
https://create.roblox.com/docs/id-id/projects/place-files
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
6. /
7. [Kelola](/docs/id-id/production/publishing/publish-experiences-and-places)
Bahasa Indonesia
Masukan
# Tempatkan file
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/place-files).
Setiap pengalaman Roblox terdiri dari satu atau lebih [tempat](/docs/id-id/projects#places) , dan Studio mengunggah data tempat Anda ke server Roblox setiap kali Anda menyimpan atau mempublikasikan ke Roblox di menu File .
Anda mungkin juga ingin mengekspor salinan lokal tempat untuk digunakan dengan sistem kontrol versi atau alat eksternal lainnya [eksternal](/docs/id-id/projects/external-tools).Untuk mengekspor tempat Anda di Studio, pilih Simpan ke File atau Unduh Salinan dari menu File .Studio menawarkan dua format file:
* .rbxl adalah format file tempat biner. Format ini kompak, tetapi tidak dapat dibaca oleh manusia.
* .rbxlx adalah format file tempat berbasis XML, yang agak sedikit lebih besar di disk daripada format biner.
## [Batas ukuran](#batas-ukuran)
Roblox mendukung tempat hingga 100 MB (104,857,600 bayt).Di luar batas itu, Simpan ke Roblox dan Terbitkan ke Roblox mungkin gagal.Data yang diunggah Studio ke Roblox sedikit lebih kecil dari format file .rbxl , jadi Anda dapat mengekspor tempat Anda ke .rbxl untuk mendapatkan gambaran tentang ukurannya.
Sangat sedikit tempat, bahkan yang paling kompleks, mencapai batas ini, dan ketika mereka melakukannya, sering karena ketidakefisienan di tempat tersebut.Lihat [Pemecahan Masalah](#troubleshoot-place-file-size) .
### [File pemulihan otomatis](#file-pemulihan-otomatis)
Jika menyimpan ke Roblox gagal karena batas ukuran file, Studio secara otomatis menghasilkan cadangan tempat Anda yang disebut file pemulihan .Frekuensi cadangan pemulihan otomatis tergantung pada apakah pengalaman Anda memiliki [Tim Membuat](/docs/id-id/projects/collaboration) diaktifkan:
* Jika Anda memiliki Tim Buat diaktifkan dan menyimpan ke Roblox gagal, Studio mencadangkan tiga save terakhir sebagai file pemulihan di sistem Anda.
* Jika Pembuatan Tim dinonaktifkan, Studio menggunakan pengaturan Pemulihan Otomatis dari File \> Pengaturan Studio .
Pada Windows, file pemulihan berlokasi di C:\\Users\\Admin\\AppData\\Local\\Roblox\\RobloxStudio\\AutoSaves.
Di macOS, Anda dapat menemukannya di /Users/your\-username/Library/Application Support/Roblox/RobloxStudio/AutoSaves/ .
## [Memecahkan masalah ukuran file tempat](#memecahkan-masalah-ukuran-file-tempat)
Jika Anda mencapai batas 100 MB pada file tempat Anda, kemungkinan ada masalah dasar yang dapat Anda perbaiki. Coba langkah berikut.
### [Pemeriksaan periksa](#pemeriksaan-periksa)
Periksa model di tempat Anda dan skrip yang terpasang untuk teks yang disamarkan atau tidak jelas.Teks ini tidak terkompres dengan baik dan bahkan bisa menjadi pintu belakang berbahaya ke tempat Anda.Sistem moderasi Roblox secara aktif menyaring model ini, tetapi jika Anda kebetulan menemukannya, hapus model dari tempat Anda, temukan model di [Toko Pencipta](https://create.roblox.com/store/models) , dan laporkan segera.
### [Bagian redundan](#bagian-redundan)
Aset tidak referensi atau tersembunyi dapat terakumulasi seiring waktu dan secara tidak perlu meningkatkan ukuran file.
1. Lihat apakah ada model atau kelompok bagian yang mengambil lebih banyak ruang daripada yang lain:
1. Ekspor file tempat Anda dan catat ukurannya di disk.
2. Buka file dalam Roblox Studio.
3. Salin dan tempel model atau kelompok bagian yang menurut Anda sangat besar.
4. Simpan file lagi dan perhatikan peningkatann ukuran filenya.
2. Periksa bagian redundan (bagian dengan ukuran dan bentuk yang sama dengan posisi yang sama) atau instans (redundan [SurfaceAppearances](/docs/id-id/reference/engine/classes/SurfaceAppearance) , teks, dll.) dan hapus mereka.Toko Pencipta memiliki plugin yang dapat membantu Anda mengidentifikasi kasus ini.
### [Sederhanakan medan](#sederhanakan-medan)
Mengurangi atau menyederhanakan medan dapat secara signifikan mengurangi ukuran tempat dan meningkatkan pelaksanaan.Menghindari fitur medan berlebihan seperti hutan padat atau bukit rumit membantu membuat pengalaman berjalan lebih cepat dan lebih efisien.Tentu saja, pengalaman harus sesuai dengan visi artistik Anda, tetapi pertimbangkan optimisasi berikut:
1. Lapisan horizontal dari bahan/penghuni yang sama jauh lebih baik daripada lapisan miring.Jika memungkinkan, cobalah untuk membatasi rincian permukaan bawah ke lapisan horizontal.
2. Aktifkan [rendering wireframe](/docs/id-id/studio/view-tab#grid-and-wireframe) dan periksa lubang berantakan atau air yang terletak di bawah permukaan tanah.Kesalahan ini dapat meningkatkan ukuran kompresi.
3. Ada plugin komunitas yang mengoptimalkan blok tanah yang tidak terlihat untuk kompresi yang lebih baik, seperti [ini](https://create.roblox.com/store/asset/133396894381603/Terrain-File-Size-Optimizer) .
### [Keandalan kolisi](#keandalan-kolisi)
[Box](/docs/id-id/reference/engine/enums/CollisionFidelity#Box) dan [Hull](/docs/id-id/reference/engine/enums/CollisionFidelity#Hull) keandalan tabrakan lebih efisien memori daripada default.Pilih meshes Anda, buka jendela [Properti](/docs/id-id/studio/properties), dan ubah nilai Ketepatan Kolisi sesuai dengan kasus penggunaan Anda.
### [Teleportasi](#teleportasi)
Jika strategi pengurangan ukuran lain gagal, Anda dapat memecah tempat Anda menjadi beberapa tempat yang lebih kecil dan menautkannya melalui [teleportasi](/docs/id-id/projects/teleport).Serialisasi dan upload terjadi di tingkat tempat, jadi pendekatan ini memungkinkan Anda untuk menumbuhkan tempat alam semesta Anda dari tempat ke tempat seiring waktu bukannya mencoba mempertahankan tempat tunggal dan besar.
| 82 |
https://create.roblox.com/docs/id-id/projects/groups
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
6. /
7. [Bekerja dalam tim](/docs/id-id/projects/groups)
Bahasa Indonesia
Masukan
# Kelompok (tim)
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/groups).
Sebuah kelompok Roblox memungkinkan banyak pencipta untuk bekerja pada pengalaman yang sama, menggunakan aset yang sama, berbagi keuntungan, dan memberikan kredit kepada semua kontributor .
Kepemilikan kelompok pengalaman membantu pencipta berkolaborasi dan beroperasi sebagai studio independen.Jika konflik muncul di dalam kelompok, Roblox tidak dapat membantu menyelesaikan atau memperkecil perselisihan.
## [Pembuatan kelompok](#pembuatan-kelompok)
Membuat kelompok biaya 100 Robux.Kelompok baru mempertahankan kemampuan tertentu di halaman warisan [Grup](https://www.roblox.com/groups), tetapi alur kerja dan opsi untuk [mengkonfigurasi peran/izin](#roles-and-permissions) dan [mengundang anggota](#invite-members) hanya tersedia di [Dashboard Pencipta](https://create.roblox.com/dashboard/creations).
Sebelum membuat grup, baca dengan cermat aturan dan harapan [untuk manajemen grup](/docs/id-id/projects/group-guidelines).
Untuk membuat grup baru:
1. Navigasikan ke [Dashboard Pencipta](https://create.roblox.com/dashboard/creations), klik menu dropdown Lihat Sebagai di sebelah kiri, dan pilih Buat Grup .
2. Di halaman pengaturan, unggah gambar untuk logo kelompok dan masukkan nama kelompok.
3. Saat siap, klik tombol Pembelian .Setelah grup dibuat, Anda akan diarahkan ke halaman profil grup di mana Anda dapat memodifikasi detail grup, termasuk menambahkan hingga tiga tautan sosial.
## [Peran dan izin](#peran-dan-izin)
Anggota kelompok dapat ditugaskan satu atau lebih dari satu peran dalam kelompok, dan setiap peran memiliki izin yang menentukan kemampuan anggotanya.
Konfigurasi peran hanya dapat diakses jika Anda adalah pemilik grup atau Anda memiliki izin untuk membuat, mengkonfigurasi, dan menugaskan peran grup.
Peran yang dibuat menggunakan halaman warisan [Grup](https://www.roblox.com/groups) akan terus beroperasi di sistem warisan dan hanya dapat dikelola melalui alur kerja warisan.Jika izin diberikan ke peran lama, anggota akan terus memiliki izin\-izin itu , jadi disarankan untuk menarik izin/peran di sistem lama dan kemudian memindahkan anggota ke sistem baru.
1. Dari [Dashboard Pencipta](https://create.roblox.com/dashboard/creations), pilih grup dari menu dropdown Lihat Sebagai dan navigasikan ke Kolaborasi ⟩ Peran .
2. Untuk setiap peran, pastikan dengan hati\-hati izin di bawah tab Izin .
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Roles-Permissions-Tab.png' alt='Permissions tab indicated for a group role on the Creator Dashboard.' title='' width='780' height='' />
| Izin Kelompok | |
| --- | --- |
| Tambahkan atau hapus anggota kelompok | Anggota dengan peran ini dapat [undang](#inviting-members) dan [hapus](#removing-members) anggota lain. |
| Tambahkan atau hapus anggota peran \[role] | Anggota dengan peran ini dapat memberikan atau menghapus peran ke/dari anggota lain di grup.Izin ini berguna untuk peran yang harus memiliki beberapa izin manajemen tetapi tidak pada tingkat super\-admin. |
| Konfigurasi peran terbatas | Anggota dengan peran ini dapat mengkonfigurasi peran yang ditugaskan dan memberikan izin kepada peran yang mereka sendiri miliki. |
| Kelola semua peran | Anggota dengan peran ini dapat membuat, menghapus, dan mengonfigurasi peran apa pun di grup. Ini adalah izin super\-administrator, karena memberikan akses hampir penuh. |
| Konfigurasi profil grup | Anggota dengan peran ini dapat memperbarui nama, deskripsi, dan metadata lainnya dari grup.Tidak termasuk mentransfer kepemilikan, yang hanya bisa dilakukan oleh pemilik. |
| Lihat riwayat aktivitas kelompok | Anggota dengan peran ini dapat melihat [riwayat aktivitas kelompok](#group-activity-history). |
| Izin Pengalaman | |
| --- | --- |
| Mainkan semua pengalaman kelompok | Anggota dengan peran ini dapat memainkan semua pengalaman yang dimiliki oleh grup, apakah itu pribadi atau publik.Tersedia secara opsional sebagai izin [per\-pengalaman](/docs/id-id/production/publishing/publish-experiences-and-places#configure-experiences). |
| Edit semua pengalaman kelompok | Anggota dengan peran ini dapat mengedit semua pengalaman dan [aset](/docs/id-id/projects/assets) dimiliki oleh kelompok.Tidak termasuk mengedit pengalaman di luar sesi kolaboratif atau menyimpan tempat dari satu pengalaman ke pengalaman lain.Tersedia secara opsional sebagai izin [per\-pengalaman](/docs/id-id/production/publishing/publish-experiences-and-places#configure-experiences). |
| Edit \& publikasikan semua pengalaman kelompok | Anggota dengan peran ini dapat mengedit pengalaman, seperti di atas, dan juga mempublikasikan pengalaman ke Roblox.Tersedia secara opsional sebagai izin [per\-pengalaman](/docs/id-id/production/publishing/publish-experiences-and-places#configure-experiences). |
| Lihat semua analisis untuk pengalaman kelompok | Anggota dengan peran ini dapat mengakses [analisis](/docs/id-id/production/analytics) dari semua pengalaman yang dimiliki oleh kelompok, bahkan jika mereka tidak memiliki akses edit.Tersedia secara opsional sebagai izin [per\-pengalaman](/docs/id-id/production/publishing/publish-experiences-and-places#configure-experiences). |
| Buat dan konfigurasi tautan berbagi | Anggota dengan peran ini dapat membuat/mengonfigurasi [tautan berbagi](/docs/id-id/production/promotion/share-links). |
| Lihat Manajer Penyimpanan Data | Anggota dengan peran ini dapat mengakses [Manajer Penyimpanan Data](/docs/id-id/cloud-services/data-stores/data-stores-manager). |
| Konfigurasi larangan untuk semua pengalaman kelompok | Anggota dengan peran ini dapat melarang dan mengelola pengguna yang dilarang untuk semua pengalaman yang dimiliki oleh kelompok. |
| Pendapatan Grup | |
| --- | --- |
| Konfigurasi pendapatan kelompok | Anggota dengan peran ini dapat melihat semua pendapatan grup, seperti di bawah, dan juga dapat mengelolanya secara langsung.Ini termasuk menyiapkan pembayaran berulang , serta mengirim pembayaran satu kali kepada kolaborator . |
| Lihat pendapatan kelompok | Anggota dengan peran ini dapat melihat keseimbangan Robux grup, pembayaran berulang yang dikonfigurasi, dan (di masa depan) fitur pencatatan pendapatan baru. |
| Buat Kampanye Iklan untuk kelompok | Anggota dengan peran ini dapat mempromosikan kelompok. |
| Otorisasi Item Avatar | |
| --- | --- |
| Konfigurasi item avatar klasik | Anggota dengan peran ini dapat mengkonfigurasi item avatar klasik seperti pakaian 2D. |
| Buat item avatar klasik | Anggota dengan peran ini dapat membuat item avatar klasik seperti pakaian 2D. |
| Akses Terbuka Cloud | |
| --- | --- |
| Kelola semua kunci API | Anggota dengan peran ini dapat mengunggah kunci [Open Cloud API](/docs/id-id/cloud/auth/api-keys) sendiri ke grup, serta mengkonfigurasi kunci semua orang lain. |
| Kelola kunci API sendiri | Anggota dengan peran ini dapat mengkonfigurasi dan mengunggah kunci [Open Cloud API](/docs/id-id/cloud/auth/api-keys) sendiri ke grup (tetapi tidak mengkonfigurasi orang lain seperti di atas). |
| Izin Aset | |
| --- | --- |
| Lihat item pengembangan | Anggota dengan peran ini dapat melihat item pengembangan yang dimiliki oleh kelompok, misalnya Audio . |
| Buat dan konfigurasi item pengembangan | Anggota dengan peran ini dapat mengunggah dan mengkonfigurasi item pengembangan aset seperti Decals . |
| Manajemen izin item pengembangan | Anggota dengan peran ini dapat mengonfigurasi izin item pengembangan, misalnya berbagi audio. |
3. Klik tombol Simpan Perubahan untuk menerapkan pengaturan izin.
4. Klik tab Pengaturan dan pilih warna untuk peran, lalu klik Simpan Perubahan .
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Roles-Settings-Tab.png' alt='Settings tab indicated for a group role on the Creator Dashboard.' title='' width='780' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Roles-Role-Color.png' alt='Color options indicated for a group role on the Creator Dashboard.' title='' width='780' height='' />Bagian Pengaturan dari peran juga merupakan tempat di mana pemilik dan anggota kelompok dengan izin yang cukup dapat menghapus peran sepenuhnya melalui tombol Hapus Peran .
## [Manajemen anggota](#manajemen-anggota)
Setelah [peran](#roles-and-permissions) telah dikonfigurasi untuk kelompok, anggota dapat diundang dan ditugaskan dari halaman Kolaborasi \> Anggota .
Konfigurasi anggota hanya dapat diakses jika Anda adalah pemilik grup atau Anda memiliki izin untuk mengelola anggota lain dan peran mereka.
### [Undang anggota](#undang-anggota)
Anda dapat mengundang anggota baru melalui tombol Undang di sudut kanan atas.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Members-Invite-Button.png' alt='Invite button indicated in the group's Members section on the Creator Dashboard.' title='' width='880' height='' />Dari popup, temukan pencipta dengan mengetik nama pengguna mereka ke bidang pencarian.Pembuat akan diberitahu ketika diundang ke grup Anda (pengaturan yang dapat disesuaikan dalam sistem pemberitahuan pembuat), atau Anda dapat menyalin tautan grup dan berbagi dengan pembuat yang diundang melalui cara lain.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Members-Invite-Popup.png' alt='Invite popup window indicated in the group's Members section on the Creator Dashboard.' title='' width='880' height='' />
### [Ambil peran](#ambil-peran)
Untuk menugaskan satu atau lebih peran kepada anggota, hover di atas namanya, klik tombol ⋮ , lalu klik tombol ⊕ untuk peran yang diinginkan.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Members-Assign-Role.png' alt='Roles management popup window showing how to assign a role to a group member on the Creator Dashboard.' title='' width='880' height='' />Untuk dengan cepat melepaskan peran dari pandangan umum anggota, hover di atasnya dan klik tombol ⊗ .
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Members-Un-Assign-Role.png' alt='Hover-over showing how to un-assign a role from a group member on the Creator Dashboard.' title='' width='880' height='' />Saat ini, peran yang dikonfigurasi melalui halaman warisan [Grup](https://www.roblox.com/groups) muncul untuk setiap anggota, dan anggota baru diberi peran warisan Anggota .Jika izin diberikan kepada peran melalui sistem warisan, anggota akan terus memiliki izin\-izin itu , jadi disarankan agar Anda menarik izin/peran di sistem warisan dan kemudian memindahkan anggota ke sistem baru.
### [Hapus anggota](#hapus-anggota)
Untuk menghapus anggota sepenuhnya, hover di atas nama mereka dan klik tombol "sampah." Dialog akan muncul untuk Anda konfirmasi penghapusan mereka.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Members-Remove-Member.png' alt='Hover-over showing how to remove a member from a group on the Creator Dashboard.' title='' width='880' height='' />
## [Kelola pembayaran](#kelola-pembayaran)
Jika Anda adalah pemilik kelompok yang dipilih, Anda akan menemukan halaman Pembayaran di bawah Keuangan .Di sini, Anda dapat mengirim pembayaran satu kali, serta menentukan pembagian persentase dengan anggota lain.
Beberapa kelompok mungkin tidak memiliki halaman ini dibuka awalnya karena berbagai alasan, seperti kelompok tidak memiliki dana untuk dibayarkan.
Pemilik kelompok tidak dapat berbagi pembayaran kepada anggota kelompok untuk pengalaman yang membebankan akses berbayar [dalam mata uang lokal](/docs/id-id/production/monetization/paid-access-local-currency).
### [Pembayaran satu kali](#pembayaran-satu-kali)
Pemilik kelompok dapat melakukan pembayaran satu kali kepada anggota dalam satu batch, memilih jumlah tetap untuk masing\-masing.Fitur keamanan termasuk tantangan 2FA, dialog konfirmasi, dan pemeriksaan di sekitar kelayakan anggota yang dibayar.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Payouts-One-Time.png' alt='One-time payout button indicated in the Payouts section on the Creator Dashboard.' title='' width='880' height='' />
### [Pembayaran berulang](#pembayaran-berulang)
Pemilik kelompok juga dapat mendefinisikan pembayaran berulang di seluruh kelompok dan per\-pengalaman, menugaskan pembayaran persentase kepada setiap anggota sebelum sisa masuk ke keseimbangan keseluruhan kelompok.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Payouts-Split-Options.png' alt='Split payout buttons indicated in the Payouts section on the Creator Dashboard.' title='' width='880' height='' />Pertimbangkan skenario berikut di mana pengalaman kelompok Laser Maze dibagi 40%–30%–10% di antara tiga anggota, dengan sisa 20%.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-A.png' alt='' title='' width='40' height='' />Mengasumsikan pengalaman mendapatkan 1000 Robux, ketiga anggota menerima 400, 300, dan 100 Robux masing\-masing (40%–30%–10%).
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-B.png' alt='' title='' width='40' height='' />Sisa 200 Robux (20% dari pembagian pengalaman) lanjut ke persentase bagi kelompok yang didefinisikan pada 20%–20%–10% di antara tiga anggota yang sama; mereka menerima tambahan 40, 40, dan 20 Robux masing\-masing.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-C.png' alt='' title='' width='40' height='' />Sisa 100 Robux (50% dari pembagian kelompok) ditempatkan dalam keseimbangan keseluruhan kelompok.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Group-Payouts-Splits-Example.png' alt='Example flowchart of how experience splits are distributed to group members first, with remainder going factored into group splits for final distribution among the group.' title='' width='840' height='' />Perhatikan bahwa pendapatan dari [langganan server pribadi](/docs/id-id/production/monetization/private-servers) tidak berubah jika Anda menyesuaikan persentase pembagian pada waktu yang lambat, artinya jika pemain membeli langganan server pribadi, persentase pembagian pada saat pembelian akan berlaku untuk langganan khusus itu selamanya (hingga dibatalkan).Kebijakan ini dapat diubah di masa depan.
## [Sejarah aktivitas kelompok](#sejarah-aktivitas-kelompok)
Anggota kelompok dengan izin Melihat riwayat aktivitas kelompok dapat melihat aktivitas terperinci seperti perubahan peran dan tindakan penerbitan dari bagian Histori aktivitas di bawah Kolaborasi di Dashboard Pencipta.Ini juga merupakan cara yang berguna bagi pemilik kelompok untuk memoderasi aktivitas yang mungkin melanggar [panduan kelompok](/docs/id-id/projects/group-guidelines) .
## [Perlindungan kekayaan intelektual](#perlindungan-kekayaan-intelektual)
Anggota kelompok dengan izin untuk mengedit semua pengalaman kelompok dapat mengaktifkan pengaturan [Penyalinan Tempat](/docs/id-id/production/publishing/publish-experiences-and-places#allow-copying) untuk sebuah kreasi, yang berpotensi memungkinkan seluruh komunitas Roblox untuk menyalin dan menggunakan aset di dalamnya.Untuk membantu melindungi kekayaan intelektual di sebuah kelompok, pemilik atau anggota dengan izin yang cukup harus:
* Konfirmasikan bahwa setiap anggota diberi peran yang tepat .
* Periksa bahwa setiap peran kelompok memiliki izin yang benar [.](#roles-and-permissions).
* Konfirmasikan bahwa pengaturan [Menyalin Tempat](/docs/id-id/production/publishing/publish-experiences-and-places#allow-copying) dinonaktifkan sebelum aset pribadi ditambahkan.
| 83 |
https://create.roblox.com/docs/id-id/projects/collaboration
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
6. /
7. [Bekerja dalam tim](/docs/id-id/projects/groups)
Bahasa Indonesia
Masukan
# Kolaborasi
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/collaboration).
Membuat pengalaman berkualitas tinggi membutuhkan banyak keterampilan seperti pemodelan, pemrograman, desain antarmuka pengguna, dan produksi audio.Kemungkinannya kecil bahwa satu orang memiliki semua keterampilan ini, yang membuat kolaborasi antara peran yang berbeda menjadi bagian penting dari alur kerja pengembangan.
Dengan alat kolaborasi bawaan Studio , pencipta dapat berkontribusi pada pengalaman secara independen pada waktu mereka sendiri, atau bekerja sama dengan tim mereka semua pada saat yang sama.
## [Manajemen kolaborator](#manajemen-kolaborator)
Kolaborator yang Anda tambahkan ke pengalaman memiliki pengaturan izin yang sesuai dengan tingkat akses mereka ke pengalaman.Seperti berikut adalah pengaturan izin pengguna yang berbeda:
| Otorisasi | Deskripsi |
| --- | --- |
| Pemilik | Pengguna adalah pemilik pengalaman dan memiliki izin untuk mengonfigurasi izin pengguna lain. |
| Edit | Pengguna memiliki izin untuk mengedit pengalaman. Ini juga memberikan izin Mainkan kepada pengguna. |
| Mainkan | Pengguna memiliki izin untuk memainkan pengalaman secara pribadi. |
| Tidak Akses | Pengguna tidak memiliki izin Edit atau Bermain . |
Ada beberapa perbedaan kecil saat mengelola kolaborator di [pengalaman milik kelompok](#group-owned-experiences) vs. [pengalaman milik pengguna](#user-owned-experiences) .
### [Pengalaman milik kelompok](#pengalaman-milik-kelompok)
Untuk pengalaman [kelompok](/docs/id-id/projects/groups), hanya pemilik kelompok atau anggota dengan izin yang cukup dapat mengelola peran kelompok, baik melintasi semua pengalaman kelompok atau pada dasar per\-pengalaman .Pengguna seperti itu juga dapat menambahkan kolaborator individu ke pengalaman milik kelompok dalam alur kerja yang sama dengan [pengalaman pengguna](#user-owned-experiences) yang dimiliki, tetapi hanya untuk akses Bermain .
Semua pengalaman kelompok
Per pengalaman
Jika Anda adalah pemilik grup atau anggota dengan izin yang cukup, Anda dapat mengkonfigurasi kolaborasi di semua pengalaman grup , misalnya memberikan izin Edit ke grup peran "Artis Audio" sehingga mereka dapat menyesuaikan pemutaran audio di berbagai pengalaman grup.
1. Dari [Dashboard Pencipta](https://create.roblox.com/dashboard/creations), pilih grup dari menu dropdown Lihat Sebagai dan navigasikan ke Kolaborasi ⟩ Peran .
2. Aktifkan [Edit semua pengalaman kelompok](/docs/id-id/projects/groups#roles-and-permissions) untuk peran yang harus memiliki izin编辑.Ingatlah untuk mengklik Simpan Perubahan untuk setiap peran yang Anda ubah.
Di jendela Manajemen Kolaborator di Studio untuk pengalaman milik kelompok, peran yang memenuhi syarat menampilkan izin Edit tetapi dibungkam untuk menunjukkan bahwa Anda tidak dapat mengubah tingkat izin dari Studio.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Collaborate-Button-From-Off.png' alt='Studio's mezzanine bar with the Collaborate button highlighted.' title='' width='754' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Edit-Permission-All-Group-Experiences.png' alt='Manage Collaborators window showing permission level selection for each group role.' title='' width='780' height='' />
### [Pengalaman yang dimiliki pengguna](#pengalaman-yang-dimiliki-pengguna)
Untuk pengalaman yang dimiliki pengguna, Anda dapat memberikan akses Bermain kepada pengguna atau [grup](/docs/id-id/projects/groups) mana pun, tetapi Anda hanya dapat memberikan izin Edit kepada teman Roblox.
Untuk memberikan izin Edit kepada teman untuk pengalaman yang Anda miliki:
1. Dengan pengalaman terbuka di Studio, klik tombol Kolaborasi di sisi kanan bar mezzanine.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Collaborate-Button-From-Off.png' alt='Studio's mezzanine bar with the Collaborate button highlighted.' title='' width='754' height='' />
2. Ketik ke bilah pencarian di bagian atas untuk mencari kolaborator untuk ditambahkan.Dropdown muncul daftar kolaborator yang cocok, dengan teman ditunjukkan oleh label Teman di bawah nama mereka.Pilih kolaborator untuk ditambahkan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Collaborator-Search.png' alt='Manage Collaborators window showing search query for a Roblox friend.' title='' width='780' height='' />
3. Pilih Edit dari dropdown izin untuk teman.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Edit-Permission-Per-User.png' alt='A close up view of a collaborator's tile with the permission dropdown menu highlighted.' title='' width='700' height='' />
4. Klik Simpan untuk pengaturan kolaborasi Anda agar berlaku.
## [Akses ke sesi](#akses-ke-sesi)
Mereka yang memiliki izin untuk mengedit pengalaman dapat bergabung dengan sesi kolaboratif sebagai berikut:
1. Navigasikan ke [Dashboard Pencipta](https://create.roblox.com/dashboard/creations).
2. Temukan pengalaman tergantung pada apakah itu [dimiliki kelompok](#group-owned-experiences) atau [dimiliki pengguna](#user-owned-experiences).
Pengalaman Dimiliki Grup
Pengalaman Dimiliki Pengguna
1. Pilih grup dari menu pemilih kiri atas.
2. Pastikan Karya dipilih di sebelah kiri dan Pengalaman Saya di panel utama.
My ExperiencesShared With Me
3. Pasang mouse di atas ubin pengalaman dan klik tombol Edit di Studio untuk berkolaborasi.
<img src='https://prod.docsiteassets.roblox.com/assets/creator-dashboard/Edit-Button-Experience.png' alt='A close up view of an experience tile with the Edit in Studio button highlighted.' title='' width='200' height='' />
### [Lihat kolaborator](#lihat-kolaborator)
Saat bekerja di sesi kolaboratif, Anda dapat melihat kolaborator saat ini di sudut kanan atas Studio, masing\-masing dengan warna yang ditugaskan unik yang konsisten di semua perangkat kolaborator.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Current-Collaborators.png' alt='Studio's menu bar with icons of the current collaborators highlighted.' title='' width='754' height='' />Untuk melihat lebih banyak rincian tentang kolaborator saat ini, klik salah satu ikon untuk membuka jendela Kolaborator Langsung .Di jendela ini, Anda dapat melihat apakah pengguna aktif atau tidak aktif di Studio, serta indikasi di mana pengguna bekerja.Pengguna menjadi tidak aktif jika tidak menggunakan Studio selama lebih dari 5 menit.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Live-Collaborators-Status.png' alt='Live Collaborators window with icons of current collaborators, as well as their activity status.' title='' width='280' height='' />
### [Visualisasi pemilihan](#visualisasi-pemilihan)
Secara default, kode yang dipilih di [Editor Skrip](/docs/id-id/studio/script-editor) dan objek yang dipilih di viewport 3D disorot dengan warna unik yang ditugaskan ke setiap kolaborator.Selain itu, jendela [Penjelajah](/docs/id-id/studio/explorer) menandai objek yang dipilih dengan titik\-titik dalam warna yang ditugaskan untuk menunjukkan pemilihan oleh kolaborator lain.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/User-Color-Parts.jpg' alt='A viewport view of a block part pyramid. The parts near the top of the pyramid are highlighted in green to signify that the collaborator with the green color has the parts selected in their Studio instance.' title='' width='420' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/User-Color-Explorer.png' alt='A close up view of the three block part objects in the Explorer window. There is a green circle near the objects to signify that the collaborator with the green color has the parts selected in their Studio instance.' title='' width='320' height='' />Untuk membuat semua pilihan kolaborator tidak terlihat hanya untuk Anda saat masih melihat pekerjaan mereka, hapus centang Tampilkan pilihan kolaborator di bagian bawah jendela [Kolaborator Langsung](#view-collaborators).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Live-Collaborators-Toggle-Selections.png' alt='' title='' width='280' height='' />
### [Bergabung dengan kolaborator](#bergabung-dengan-kolaborator)
Untuk segera melompat ke lokasi di ruang kerja atau ke baris yang tepat dalam skrip yang diedit oleh kolaborator, hover over nama mereka di jendela [Kolaborator Langsung](#view-collaborators) dan klik Bergabung .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Live-Collaborators-Join.png' alt='' title='' width='280' height='' />
## [Umpan Balik](#umpan-balik)
Fitur komentar diluncurkan secara bertahap selama bulan depan. Semua pengguna Studio akan memiliki akses pada 30 Mei 2025\.
Roblox Studio memiliki fitur komentar yang memungkinkan Anda menentukan objek di jendela pandang 3D dan memulai percakapan dengan kolaborator Anda, meninggalkan catatan to\-do, dan banyak lagi.Komentar diperbarui secara real time, yang memungkinkan Anda dan tim Anda menerima dan menanggapi umpan balik tanpa mengganggu alur kerja di Studio.
Untuk menggunakan fitur ini, Anda harus memiliki [kolaborator tambahan](#manage-collaborators) ke pengalaman Anda.
### [Buat komentar](#buat-komentar)
Untuk membuat komentar, klik tombol Komentar di sudut kanan atas Studio (pendekatan pintas keyboard C).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/comments/annotations-button.png' alt='Button for comments in the upper-right.' title='' width='400' height='' />Di jendela pandang, perhatikan bagaimana kursor Anda berubah biru.Klik pada objek apa pun yang mewarisi dari [BasePart](/docs/id-id/reference/engine/classes/BasePart) (kebanyakan melakukannya, termasuk medan), ketik komentar Anda, dan klik Kirimkan .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/comments/annotations-blue.png' alt='Blue cursor in the viewport.' title='' width='300' height='' />Untuk menandai kolaborator dalam komentar Anda, gunakan syntax @username.Kolaborator kemudian dapat memeriksa jendela [Komentar](#manage-comments) dan menyaring komentar yang menyebutkan mereka.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/comments/annotations-tag.png' alt='Creating a comment in the viewport.' title='' width='700' height='' />* Dalam pengalaman yang dimiliki pengguna, setiap pengguna dengan izin bermain atau mengedit tersedia di dropdown penandaan.
* Dalam pengalaman yang dimiliki kelompok, setiap pengguna di dalam kelompok tersedia di dropdown penandaan.
### [Manajemen komentar](#manajemen-komentar)
Jendela Komentar menunjukkan daftar semua komentar, dengan yang paling baru di bagian atas.Untuk membuka jendela, beralih ke tab Tampilan dan klik tombol Komentar .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/comments/annotations-window.png' alt='List of comments in the window.' title='' width='400' height='' />* Klik tunggal pada komentar untuk menampilkan percakapan lengkap.
* Klik dua kali pada komentar untuk memperbesar di jendela pandang.
* Gunakan menu ⋯ di pojok kanan atas untuk menampilkan komentar yang diselesaikan, filter hanya komentar yang telah Anda tandai, atau sembunyikan komentar di jendela pandang.
* Memecahkan komentar saat Anda dan tim menanganinya.Setelah Anda menyelesaikan komentar, itu menghilang dari kedua jendela dan daftar utama, tetapi tidak sepenuhnya hilang; Anda selalu dapat memecahkannya nanti.
## [Skrip kolaboratif](#skrip-kolaboratif)
Dalam sesi kolaboratif, Anda dapat mengkode bersama\-sama secara real time melalui [skrip langsung](#live-scripting) , atau Anda dapat [menyusun](#drafts-mode) skrip di lingkungan yang lebih fokus sebelum menyimpannnya ke repositori bersama\-berbagi kolaborator.
### [Skrip hidup](#skrip-hidup)
Skrip Langsung memungkinkan kolaborator mengkode bersama dalam waktu nyata.Di [Editor Skrip](/docs/id-id/studio/script-editor), warna kursoр setiap kolaborator sesuai dengan warna yang ditugaskan mereka di jendela [Kolaborator Langsung](#view-collaborators).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Live-Scripting-Cursors.png' alt='Script Editor window showing cursors for two collaborators, colored according to their assigned color in the Live Collaborators window.' title='' width='520' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Live-Collaborators-Status.png' alt='Live Collaborators window with icons of current collaborators, as well as their activity status.' title='' width='280' height='' />Saat menulis skrip langsung, perubahan disimpan otomatis setiap 5 menit seperti perubahan tempat, dan kolaborator dapat menyimpan skrip secara manual kapan saja dengan CtrlS ( ⌘S ).Versi yang disimpan atau disimpan otomatis dicatat di jendela [Histori Skrip](#view-script-history).
Skrip Langsung diaktifkan untuk default .Jika Anda dan tim lebih suka berkolaborasi pada skrip di lingkungan yang mirip dengan kontrol sumber, jelajahi mode [draft](#drafts-mode) .
### [Mode naskah](#mode-naskah)
Melalui mode draft , Anda dapat secara independen mengedit dan menguji skrip tanpa memengaruhi pengalaman bagi orang lain.Setelah Anda menyelesaikan menyusun naskah, Anda dapat [komitkan](#commit-drafts) ke repositori bersama dan [Tes Tim](/docs/id-id/studio/home-tab#team-test) versi yang diberikan dengan kolaborator.
Mode draft adalah dinonaktifkan secara default.Untuk mengaktifkannya, buka jendela File \> Pengaturan Permainan di Studio, pilih tab Lainnya dan nyalakan Aktifkan Mode Rancangan .
Perhatikan bahwa semua kolaborator harus keluar dari sesi agar perubahan berlaku.Alternatifnya, Anda dapat [menonaktifkan kolaborasi](#disable-collaboration) dan kemudian mengaktifkannya kembali untuk memulai ulang sesi.
#### [Komitkan draft](#komitkan-draft)
Setelah Anda menyunting skrip, itu muncul di jendela Rancangan , yang dapat diakses dari tab [Lihat](/docs/id-id/studio/view-tab).Rancangan disimpan ke sistem file lokal Anda dan bertahan di antara sesi Studio di komputer yang sama.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Drafts.png' alt='Studio's View tab with the Drafts button highlighted.' title='' width='776' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Drafts-Window.png' alt='The Drafts window with two drafted script instances.' title='' width='360' height='' />Untuk melakukan komitmen edit lokal Anda ke repositori, klik kiri pada skrip, atau tahan Shift dan klik kiri untuk memilih beberapa skrip.Kemudian klik Komit untuk melakukan komit semua skrip yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Drafts-Commit.png' alt='The Drafts window with the Commit button highlighted.' title='' width='360' height='' />
#### [Bandingkan dan gabungkan perubahan](#bandingkan-dan-gabungkan-perubahan)
Jika kolaborator lain melakukan perubahan pada skrip yang sama yang Anda edit, ikon dengan simbol ⊕ hijau muncul di jendela draft .Untuk melihat perubahan mereka, klik kanan skrip dan pilih Bandingkan dengan Server .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Drafts-Compare.png' alt='The Drafts window with the green plus icon highlighted to the left of a changed script, and the right-click popup window showing with the Compare With Server option highlighted.' title='' width='360' height='' />Di tab (Perbedaan) yang terbuka di [Editor Skrip](/docs/id-id/studio/script-editor), kode yang diubah atau dihapus oleh kolaborator lain muncul dalam warna merah, sementara kode yang Anda perbarui muncul dalam warna hijau.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Drafts-Diff-Result.png' alt='A close up view of lines that were edited by different collaborators.' title='' width='800' height='' />Untuk menggabungkan perubahan mereka ke dalam skrip Anda:
1. Di jendela Rancangan , klik kanan pada skrip dan pilih Gabung dari Server .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Drafts-Merge.png' alt='The Drafts window right-click popup window showing with the Merge From Server option highlighted.' title='' width='360' height='' />
2. Di jendela gabungan, Anda dapat memilih kode mana yang akan disimpan, atau melakukan编辑 manual.
* Periksa Rancangan untuk menyimpan perubahan Anda, atau tinggalkan tidak dipilih untuk menyingkirkannya.
* Periksa Server untuk menggabungkan perubahan yang dijanjikan ke dalam draft Anda, atau tinggalkan tidak dipilih untuk mengabaikannya.
* Periksa Lainnya untuk secara manual mengedit skrip dan menyimpan perubahan pada draft Anda.
3. Setelah Anda meninjau resolusi gabungan, klik Gabungkan Semua untuk memperbarui skrip lokal Anda.
#### [Restorasi skrip yang dihapus](#restorasi-skrip-yang-dihapus)
Jika kolaborator menghapus skrip yang Anda edit, ikon dengan simbol ⊘ merah muncul di jendela Rancangan .Untuk memulihkan skrip, klik kanan dan pilih Pulihkan Skrip .Skrip dipulihkan ke pohon Ruang kerja tempat, jadi Anda mungkin perlu secara manual memindahkan mereka kembali ke lokasi asal mereka.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Drafts-Restore.png' alt='The Drafts window with the red cross icon highlighted to the left of a deleted script, and the right-click popup window showing with the Restore Script option highlighted.' title='' width='360' height='' />
### [Lihat riwayat skrip](#lihat-riwayat-skrip)
Semua perubahan skrip, baik disimpan oleh kolaborator, disimpan secara otomatis, atau ditangani oleh kolaborator melalui mode [Draf](#drafts-mode), dicatat di jendela Histori Versi .Untuk mengaksesnya:
1. Klik kanan skrip di jendela [Explorer](/docs/id-id/studio/explorer) dan pilih Lihat Histori Skrip .
2. Di jendela Sejarah Versi yang terbuka, Anda akan melihat semua versi yang dikomitkan dari skrip, tanggal komit, kolaborator yang berkomit, dan banyak lagi.Dari jendela ini, tindakan berikut adalah mungkin:
Bandingkan dengan Sebelumnya
Bandingkan yang Dipilih
Buka
Untuk membandingkan versi mana pun (kecuali yang tertua) dengan versi sebelumnya, pilih dan klik Bandingkan dengan Versi Sebelumnya .Di tab (Perbedaan) yang terbuka di [Editor Skrip](/docs/id-id/studio/script-editor), kode dari versi baru muncul dalam warna hijau sementara kode dari versi lama muncul dalam warna merah.
## [Simpan dan publikasikan](#simpan-dan-publikasikan)
Selama sesi kolaboratif, Studio secara otomatis menyimpan proyek ke cloud setiap empat menit.
## [Kembalikan ke versi sebelumnya](#kembalikan-ke-versi-sebelumnya)
Pemilik pengalaman dapat membalikkan perubahan yang dilakukan oleh editor lain. Lihat [di sini](/docs/id-id/production/publishing/publish-experiences-and-places#revert-to-previous-versions) untuk instruksi.
Hati\-hati saat membalikkan perubahan.Jika seseorang saat ini sedang mengedit pengalaman dalam sesi kolaboratif, perubahan mereka masih dapat disimpan otomatis dan menghapus tindakan pembalikan.Untuk memastikan tidak ada orang lain yang mengedit tempat saat Anda kembali, [nonaktifkan kolaborasi](#disable-collaboration) .
Anda mungkin juga ingin memeriksa [Histori Aktivitas](/docs/id-id/projects/activity-history).Pandangan ini memberikan log peristiwa kronologis yang meningkatkan visibilitas tim ke pengaturan pengalaman kunci.
## [Nonaktifkan kolaborasi](#nonaktifkan-kolaborasi)
Pembuatan Tim adalah fitur Studio inti yang memungkinkan kolaborasi.Workflow yang melibatkan dialog [Manajemen Kolaborator](#manage-collaborators) akan secara otomatis mengaktifkan fitur ini, tetapi Anda dapat secara manual menonaktifkannya jika diperlukan.
1. Jika jendela [Kolaborator Langsung](#view-collaborators) belum terbuka, klik salah satu ikon kolaborator untuk membukanya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Toolbar-Current-Collaborators.png' alt='' title='' width='754' height='' />
2. Di sudut kanan bawah jendela, klik tombol ⋯ dan pilih Nonaktifkan Pembuatan Tim .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/collaboration/Live-Collaborators-Disable.png' alt='' title='' width='280' height='' />
3. Ketika diminta, konfirmasikan mengakhiri sesi untuk memuat ulang tempat dalam keadaan non\-kolaboratif.
| 84 |
https://create.roblox.com/docs/id-id/projects/activity-history
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
6. /
7. [Bekerja dalam tim](/docs/id-id/projects/groups)
Bahasa Indonesia
Masukan
# Sejarah aktivitas
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/activity-history).
Tampilan Sejarah Aktivitas di Studio adalah log bersama dari perubahan kunci dalam pengalaman. Setiap entri memberi tahu Anda:
* Apa yang berubah
* Siapa yang mengubahnya
* Ketika mereka membuat perubahan
Anda dapat menemukan informasi serupa di halaman Aktivitas Histori pengalaman di [Pusat Pencipta](https://create.roblox.com/dashboard/creations), meskipun kedua pandangan memiliki beberapa perbedaan.Lihat [Referensi Acara](#event-reference).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Activity-History.png' alt='A view of the Activity History window showing various changes and updates.' title='' width='360' height='' />Untuk membuka tampilan Histori Aktivitas di Studio, pengalaman Anda harus disimpan ke Roblox.
1. Di tab [Tampilan](/docs/id-id/studio/view-tab), pilih Histori Aktivitas . Acara ditampilkan dalam urutan kronologis, dengan yang paling baru muncul pertama.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/View-Tab-Activity-History.png' alt='Activity History tool indicated in the View tab.' title='' width='720' height='' />
2. Jika Anda memiliki banyak acara, Anda dapat menyaringnya berdasarkan jenis atau kolaborator.
3. Jika Anda ingin mengelola konfigurasi atau mendapatkan lebih banyak rincian tentang perubahan, gunakan menu ⋯ di samping setiap peristiwa untuk mendapatkan tautan ke pengaturan di Studio atau Hub Pencipta.
## [Referensi acara](#referensi-acara)
Sejarah Aktivitas menunjukkan peristiwa berikut. Kebanyakan terlihat di Studio dan Hub Pencipta, tetapi beberapa hanya terlihat di satu lokasi atau yang lain.
### [Konfigurasi tempat](#konfigurasi-tempat)
Acara \| Ditampilkan di Studio \| Ditampilkan di Creator Hub :\-\-\- \| :\-\-\-: \| :\-\-\-: Tempat diterbitkan \| ✓ \| ✓ Nama tempat diubah \| ✓ \| ✓ Tempat ditambahkan ke pengalaman \| \| ✓ Tempat dihapus dari pengalaman \| \| ✓ Izinkan tempat untuk disalin sebagai templat menggunakan API Tempat Buat diubah \| ✓ \| ✓ Izinkan tempat untuk diperbarui menggunakan API Penyimpanan Tempat diubah \| ✓ \| ✓
### [Tempatkan perubahan](#tempatkan-perubahan)
Acara \| Ditampilkan di Studio \| Ditampilkan di Hub Pencipta :\-\-\- \| :\-\-\-: \| :\-\-\-: Naskah naskah ditangani \| ✓ \|
### [Konfigurasi pengalaman](#konfigurasi-pengalaman)
Peristiwa \| Ditampilkan di Studio \| Ditampilkan di Creator Hub :\-\-\- \| :\-\-\-: \| :\-\-\-: Pengalaman berubah menjadi publik atau pribadi \| ✓ \| ✓ Nama pengalaman diubah \| ✓ \| ✓ Deskripsi pengalaman diubah \| ✓ \| ✓ Pengalaman disimpan \| ✓ \| ✓ Pertanyaan rekomendasi usia diperbarui \| ✓ \| ✓ Menutup semua server yang digunakan \| ✓ \| ✓ Perangkat yang dapat dimainkan diubah \| ✓ \| ✓ Pertanyaan rekomendasi usia diperbarui \| ✓ \| ✓
### [Pengaturan monetarisasi](#pengaturan-monetarisasi)
Acara \| Ditampilkan di Studio \| Ditampilkan di Creator Hub :\-\-\- \| :\-\-\-: \| :\-\-\-: Akses Berbayar diaktifkan atau dinonaktifkan \| ✓ \| ✓ Harga akses berbayar berubah \| ✓ \| ✓ Server pribadi diaktifkan atau dinonaktifkan \| ✓ \| ✓ Harga server pribadi berubah \| ✓ \| ✓
### [Notifikasi](#notifikasi)
Acara \| Ditampilkan di Studio \| Ditampilkan di Hub Pencipta :\-\-\- \| :\-\-\-: \| :\-\-\-: Tali pemberitahuan yang dibuat \| \| ✓ Tali pemberitahuan dihapus \| \| ✓ Tali pemberitahuan diperbarui \| \| ✓
Untuk informasi lebih lanjut, lihat [Notifikasi pengalaman](/docs/id-id/production/promotion/experience-notifications).
### [Izin kolaborasi](#izin-kolaborasi)
Acara \| Ditampilkan di Studio \| Ditampilkan di Creator Hub :\-\-\- \| :\-\-\-: \| :\-\-\-: Kolaborator ditambahkan dengan izin edit atau bermain \| ✓ \| ✓ Izin kolaborator tingkat berubah \| ✓ \| ✓ Kolaborator dihapus \| ✓ \| ✓ Izin peran kelompok untuk pengalaman ini diubah \| ✓ \| ✓ Izin peran kelompok dengan izin bermain dihapus \| ✓ \| ✓ Grup diberi izin bermain \| ✓ \| ✓ Grup dengan izin bermain dihapus \| ✓ \| ✓ Izin peran kelompok untuk pengalaman ini diubah \| ✓ \| ✓
Untuk informasi lebih lanjut, lihat [Peran dan izin kelompok](/docs/id-id/projects/groups#roles-and-permissions).
| 85 |
https://create.roblox.com/docs/id-id/projects/external-tools
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Proyek](/docs/id-id/projects)
Bahasa Indonesia
Masukan
# Alat pihak ketiga
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/projects/external-tools).
Untuk studio pengembangan profesional, mengatur alat pihak ketiga dan berinvestasi dalam otomatisasi dapat secara dramatis meningkatkan produktivitas pengembang.Pendekatan awan pertama Roblox memiliki banyak keuntungan, tetapi memindahkan bagian tertentu dari alur kerja pengembangan ke luar awan dapat membantu tim yang lebih besar melacak perubahan seiring waktu, meninjau kode, dan menggunakan bahasa dan alat yang sudah mereka kenal.
Meskipun halaman ini mencakup beberapa alat populer, seharusnya tidak dianggap sebagai rekomendasi ketat dari mereka.Setiap tim memiliki kebutuhan yang berbeda, jadi halaman ini dimaksudkan untuk membantu Anda memeriksa cara untuk meningkatkan alur kerja Anda daripada memberi tahu Anda untuk mengunduh sesuatu khususnya.
Alat yang disebutkan di halaman ini tidak dirawat oleh Roblox dan dapat berubah atau berhenti bekerja kapan saja.
## [Masalah sinkronisasi](#masalah-sinkronisasi)
Pada intinya, menggunakan alat eksternal dengan Roblox adalah masalah sinkronisasi *:*
* Anda ingin skrip Roblox Anda ada sebagai .luau file di disk sehingga Anda dapat menggunakan alat sendiri untuk bekerja di atasnya.
* Anda harus mendapatkan file Anda kembali ke proyek Roblox Anda setelah Anda selesai mengerjakannya.
* Jika orang lain mengubah file yang sama di antara waktu, Anda harus menangani konflik apa pun.
Untuk solusi keseluruhan untuk terasa tanpa batas dan otomatis, Anda perlu a) mendengarkan perubahan pada file dan b) mengintegrasikan perubahan ini kembali ke Studio.Dengan kata lain, Anda membutuhkan server dan plugin Studio, yang adalah cara [Rojo](https://rojo.space/) memecahkan masalah ini.
Daripada pendekatan awan pertama Roblox, Rojo memungkinkan pendekatan "sistem file terlebih dahulu"Ini mengekstrak semua file skrip di proyek Anda ke file Luau.Kemudian menjalankan server.Plugin Rojo terhubung ke server untuk menyinkronkan file\-file tersebut dengan Studio.
## [Pasang Rojo dengan Foreman](#pasang-rojo-dengan-foreman)
Anda dapat secara manual mengunduh dan menjalankan binary Rojo, tetapi pendekatan itu berisiko penggunaan pengembang yang berbeda di tim Anda menggunakan versi Rojo yang berbeda.Solusi yang lebih baik adalah menggunakan manajer alat seperti [Foreman](https://github.com/Roblox/foreman), yang menggunakan file konfigurasi \- daftar repositori dan versi \- untuk membuat proses instalasi dan upgrade konsisten di antara mesin.
Karena mengelola lingkungan pengembangan dasar Anda daripada paket dalam proyek Anda, Foreman lebih mirip dengan [nvm](https://github.com/nvm-sh/nvm) daripada [npm](https://www.npmjs.com/), tetapi perbandingan tidak sempurna.Sebuah file sederhana foreman.toml tampak seperti ini:
```
---
```
[tools]
rojo = { github = "rojo-rbx/rojo", version = "7.4.1" }
wally = { github = "UpliftGames/wally", version = "0.3.2" }
```
```
Kemudian Anda menginstal alat ini dengan foreman install .Selain file global foreman.toml , Foreman mendukung file per proyek, sehingga Anda dapat dengan mudah menggunakan versi berbeda dari Rojo, Wally, atau alat lain untuk proyek yang berbeda dan menyimpan seluruh tim Anda pada versi yang sama.
Ketika alat merilis versi baru, Anda kemudian secara eksplisit meningkatkan nomor versi di file .toml Anda, gunakan Foreman untuk melakukan upgrade, uji versi baru, dan turunkan jika menyebabkan masalah.Untuk perintah dan instruksi instalasi, lihat [Foreman](https://github.com/Roblox/foreman?tab=readme-ov-file#installation) .
## [Jalankan Rojo](#jalankan-rojo)
Setelah Anda menginstal Rojo dengan Foreman, apa yang benar\-benar Anda instal adalah server Rojo. Langkah berikutnya adalah menginstal plugin Rojo untuk Roblox Studio:
```
---
```
rojo plugin install
```
```
Kemudian hasilkan struktur proyek untuk pengalaman baru Anda dan buat:
```
---
```
rojo init my-new-experience
cd my-new-experience
rojo build -o my-new-experience.rbxl
```
```
Alternatifnya, Anda dapat [memindahkan pengalaman yang ada](https://rojo.space/docs/v7/getting-started/existing-game/). Either way, setelah Anda memiliki proyek, mulai server Rojo:
```
---
```
rojo serve
```
```
Di Roblox Studio, buka file .rbxl yang baru saja Anda buat, mulai plugin Rojo, dan terhubung ke server yang sekarang berjalan, di mana Anda dapat mulai membuat perubahan di editor teks favorit Anda dan menyaksikan perubahan itu secara otomatis disinkronkan kembali ke Studio.
Proyek Rojo memiliki persyaratan nama tertentu untuk file, banyak opsi konfigurasi, dan beberapa batasan, semua yang ditutupi dalam dokumentasi [Rojo](https://rojo.space/docs/v7/).
## [Manajer paket](#manajer-paket)
Roblox memiliki serangkaian API yang kuat yang termasuk, tetapi jika Anda ingin memanfaatkan paket perangkat lunak komunitas dengan cara yang konsisten dan dapat diulang, Anda membutuhkan manajer paket.[Wally](https://wally.run/) adalah pilihan populer.Anda dapat menginstalnya melalui Foreman, seperti Rojo.
Dalam direktori Rojo pengalaman Anda, jalankan wally init . Kemudian tambahkan paket yang diinginkan ke wally.toml . File mungkin terlihat seperti ini:
```
---
```
[package]
name = "my-home-directory/my-new-experience"
version = "0.1.0"
registry = "https://github.com/UpliftGames/wally-index"
realm = "shared"
[dependencies]
react = "jsdotlua/react@17.1.0"
react-roblox = "jsdotlua/react-roblox@17.1.0"
cryo = "phalanxia/cryo@1.0.3"
```
```
Kemudian jalankan wally install .Wally membuat direktori Packages dan mengunduh paket yang ditentukan di sana.Langkah terakhir adalah menambahkan direktori Packages ke Rojo sehingga kontennya disinkronkan kembali ke Roblox.Buka default.project.json dan tambahkan jalur.Untuk kesederhanaan, contoh ini menambahkan seluruh direktori ke [ReplicatedStorage](/docs/id-id/reference/engine/classes/ReplicatedStorage) sehingga semua paket tersedia untuk semua skrip, tetapi Anda mungkin lebih suka menambahkan paket khusus ke [ServerScriptService](/docs/id-id/reference/engine/classes/ServerScriptService) atau [StarterPlayerScripts](/docs/id-id/reference/engine/classes/StarterPlayerScripts) :
```
---
```
{
"name": "my-new-experience",
"tree": {
"$className": "DataModel",
"ReplicatedStorage": {
"Shared": {
"$path": "src/shared"
},
"Packages": {
"$path": "Packages"
}
},
...
}
}
```
```
Kemudian Anda dapat memerlukan paket dalam skrip Anda seperti yang lain [ModuleScript](/docs/id-id/reference/engine/classes/ModuleScript) :
```
---
```
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local React = require(ReplicatedStorage.Packages.react)
local ReactRoblox = require(ReplicatedStorage.Packages["react-roblox"])
local handle = Instance.new("ScreenGui", Players.LocalPlayer.PlayerGui)
local root = ReactRoblox.createRoot(handle)
local helloFrame = React.createElement("TextLabel", {
Text = "Hello World!",
Size = UDim2.new(0, 200, 0, 200),
Position = UDim2.new(0.5, 0, 0.5, 0),
AnchorPoint = Vector2.new(0.5, 0.5),
BackgroundColor3 = Color3.fromRGB(248, 217, 109),
Font = Enum.Font.LuckiestGuy,
TextSize = 24
})
root:render(helloFrame)
```
```
Seperti kebanyakan proyek perangkat lunak lainnya, tujuannya adalah agar kontributor dapat menyalin repositori, menginstal Foreman, menjalankan beberapa perintah, dan memiliki lingkungan pengembangan yang sama dengan sisa tim.
Untuk panduan lengkap tentang penggunaan React untuk membuat UI Roblox, lihat [React \+ Roblox](https://devforum.roblox.com/t/how-to-react-roblox/2964543).
## [Kontrol versi](#kontrol-versi)
Memiliki serangkaian file teks sederhana di komputer Anda membuka berbagai kemampuan, tetapi yang utama adalah *kontrol versi*.Anda dapat menyimpan skrip dan file konfigurasi Anda di repositori [Git](https://git-scm.com/) atau [Mercurial](https://www.mercurial-scm.org/); menyimpan repositori remote dan memeriksa perubahan kode di [GitHub](https://github.com), [GitLab](https://gitlab.com), atau [Bitbucket](https://bitbucket.org); dan gunakan editor teks mana pun yang Anda suka.
[Kode Visual Studio](https://code.visualstudio.com) memiliki ekosistem ekstensi terbesar, tetapi [Sublime Text](https://www.sublimetext.com) , [Notepad\+\+](https://notepad-plus-plus.org) , dan [Vim](https://www.vim.org) semuanya adalah pilihan populer.Editor mana pun yang Anda pilih, sesuai dengan kemampuan editor skrip Studio akan memerlukan beberapa ekstensi.
Anda juga mungkin mempertimbangkan untuk menambahkan:
* Sebuah linter seperti [selene](https://github.com/Kampfkarren/selene) untuk menangkap masalah umum dan memaksakan standar pemrograman
* Pembentuk kode seperti [StyLua](https://github.com/JohnnyMorganz/StyLua)
* Server bahasa seperti [Luau Language Server](https://github.com/JohnnyMorganz/luau-lsp) untuk penyelesaian otomatis, pemeriksaan jenis, dan banyak lagi
* [Buka skrip Cloud](/docs/id-id/cloud/guides) (tidak disinkronkan ke Studio) ke [memperbarui pengalaman yang dipublikasikan](/docs/id-id/cloud/reference/Universe#Cloud_UpdateUniverse) atau [memulai ulang server](/docs/id-id/cloud/reference/Universe#Cloud_RestartUniverseServers)
## [Aktiva](#aktiva)
Alat\-alat di halaman ini paling sesuai dengan skrip; seniman 3D sudah menggunakan alat eksternal seperti Blender dan Maya, menyimpan file sumber dalam kontrol versi, dan mengimpor kreasi mereka ke Studio.Setelah Anda memiliki aset Studio, kami sarankan untuk memanfaatkan [paket](/docs/id-id/projects/assets/packages) kapan pun mungkin.
Implementasi paket Roblox mengikuti banyak prinsip yang sama dengan alat di halaman ini: repositori terpusat dengan riwayat versi yang menawarkan cara lancar untuk menyimpan semua salinan aset dalam sinkronisasi.Untuk informasi lebih lanjut tentang bagaimana mereka dapat meningkatkan alur kerja Anda, lihat [Paket](/docs/id-id/projects/assets/packages).
## [Membatalkan semuanya](#membatalkan-semuanya)
Karena alat pihak ketiga menyinkronkan perubahan kembali ke Roblox Studio daripada menggantikannya, tidak ada bagian dari alur kerja ini yang melibatkan pengunci.Kapan saja, Anda dapat berhenti menggunakan satu atau semua alat ini dan kembali mengedit pengalaman Anda secara eksklusif di Studio.Kekurangan risiko membuat eksperimen dengan alat pihak ketiga terlihat sangat menarik.
| 86 |
https://create.roblox.com/docs/id-id/workspace
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
Bahasa Indonesia
Masukan
# Ruang kerja 3D
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/workspace).
[Workspace](/docs/id-id/reference/engine/classes/Workspace) adalah layanan kontainer yang menyimpan objek yang ingin Anda tampilkan di dunia 3D oleh Roblox Engine.Biasanya Anda akan menambahkan objek ini ke ruang kerja:
* [BasePart](/docs/id-id/reference/engine/classes/BasePart) objek, yang mencakup kedua [Part](/docs/id-id/reference/engine/classes/Part) dan [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) objek.
* [Attachment](/docs/id-id/reference/engine/classes/Attachment) objek, yang dapat Anda lampirkan ke generator efek khusus seperti [ParticleEmitter](/docs/id-id/reference/engine/classes/ParticleEmitter) , objek UI seperti [BillboardGui](/docs/id-id/reference/engine/classes/BillboardGui) , fisik [Constraints](/docs/id-id/reference/engine/classes/Constraint) , dan banyak lagi.
* [Model](/docs/id-id/reference/engine/classes/Model) objek yang mengatur kelompok geometris.
* [Script](/docs/id-id/reference/engine/classes/Script) objek yang diparent oleh objek lain di ruang kerja. Skrip tidak ditampilkan tetapi dapat memengaruhi penyajian objek lain.
## [Suku Cadang](#suku-cadang)
[Part](/docs/id-id/reference/engine/classes/Part) objek mewakili blok bangunan primitif di Roblox.Secara default, semua bagian memiliki fisika mereka disimulasikan dan ditampilkan jika muncul di ruang kerja 3D.Bagian dapat mengambil bentuk blok, bola, silinder, balok sudut, atau balok sudut.Selain itu, [TrussPart](/docs/id-id/reference/engine/classes/TrussPart) bertindak sebagai rangka batang yang karakter dapat panjat seperti tangga.
| Blok | Bola | Silinder | Pengunci | Pasak sudut |
| --- | --- | --- | --- | --- |
| A single gray block part | A single gray sphere part | A single gray cylinder part | A single gray wedge part | A single gray corner wedge part |
Anda juga dapat menerapkan operasi [modeling solid](/docs/id-id/parts/solid-modeling) ke bagian, seperti persatuan atau penyangkal, untuk menggabungkannya menjadi sesuatu yang lebih kompleks seperti mangkuk atau pipa kosong.
## [Gerobak](#gerobak)
A [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) adalah objek yang mewakili mesh ( koleksi vertikal, sudut, dan wajah yang membentuk objek 3D )Anda biasanya membuat meshes menggunakan perangkat lunak pihak ketiga seperti [Blender](https://www.blender.org) atau [Maya](https://www.autodesk.com/products/maya/overview), lalu menge导入nya sebagai [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) menggunakan Studio.
Meshes dapat menyertakan banyak rincian daripada model padat apa pun yang dapat Anda lakukan di Studio.Mereka juga dapat memiliki rig dan tekstur internal, memungkinkan Anda untuk membuat objek seperti kehidupan yang dapat Anda ciptakan dan animasikan.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/meshes/Mesh-Textured.jpg' alt='A high-quality treasure chest mesh with a texture.' title='' width='100%' height='' />
*Mesh dengan tekstur*
\>
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/meshes/Mesh-SurfaceAppearance.jpg' alt='A realistic looking leafy bush with shadows and depth.' title='' width='100%' height='' />
*Mesh dengan Tampilan Permukaan*
\>
## [Tanah](#tanah)
Objek [Terrain](/docs/id-id/reference/engine/classes/Terrain) memungkinkan Anda untuk menghasilkan dan memahat lingkungan medan terperinci dan realistis, seperti gunung, badai air, bukit yang ditumbuhi rumput, atau padang pasir datar.Menggunakan Editor [Tanah](/docs/id-id/studio/terrain-editor), Anda dapat dengan mudah menghasilkan dan mengubah wilayah tanah besar.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Showcase.jpg' alt='A viewport view of desert terrain with mountains in the distance.' title='' width='100%' height='' />
## [Model](#model)
A [Model](/docs/id-id/reference/engine/classes/Model) adalah objek wadah untuk kelompok geometris , seperti [BasePart](/docs/id-id/reference/engine/classes/BasePart) , [Motor6D](/docs/id-id/reference/engine/classes/Motor6D) objek, dan model lainnya.Model dapat menjadi kumpulan sederhana atau Anda dapat menetapkan bagian utama dalam model, sehingga berfungsi sebagai kumpulan, yang ditangani oleh mesin fisika sebagai tubuh kaku tunggal.Model juga dapat berisi skrip yang bertindak pada objek individu model.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/model-objects/Model-Example-3D.jpg' alt='A humanoid model of a creepy girl with four red eyes standing in an A pose. She wears a maroon dress with webs and bright red stockings.' title='' width='100%' height='' />
*Sebuah model bernama Octavia*
\>
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/model-objects/Model-Example-Hierarchy.png' alt='A close up view of the model's children in the Explorer window that comprise the model.' title='' width='320' height='' />
*Kumpulan yang membentuk model*
\>
## [Akses ruang kerja dalam skrip](#akses-ruang-kerja-dalam-skrip)
Dalam sebuah skrip, Anda dapat mengakses tempat [Workspace](/docs/id-id/reference/engine/classes/Workspace) di tiga cara berbeda, semua di antaranya valid.
* game:GetService("Workspace")
* workspace
* game.Workspace
Dari sana, Anda dapat melakukan serangkaian besar kasus penggunaan untuk melakukan logika skrip untuk pengalaman Anda dan membuat dunia dinamis dan interaksi. Misalnya:
* Dapatkan referensi ke objek di ruang kerja untuk mengubah propertinya selama runtime.
* Dapatkan referensi ke objek pengguna [Camera](/docs/id-id/reference/engine/classes/Camera) untuk [memanipulasi pandangannya](/docs/id-id/workspace/camera) dari ruang kerja.
* Dengarkan peristiwa pada objek di ruang kerja untuk melakukan logika pada waktu tertentu, seperti ketika karakter bermain pengguna [menyentuh objek](/docs/id-id/workspace/collisions) .
| 87 |
https://create.roblox.com/docs/id-id/parts
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
6. /
7. [Bagian](/docs/id-id/parts)
Bahasa Indonesia
Masukan
# Suku Cadang
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/parts).
[Parts](/docs/id-id/reference/engine/classes/Part) adalah keturunan kelas [BasePart](/docs/id-id/reference/engine/classes/BasePart) dan merupakan blok bangunan dasar Roblox dengan properti seperti posisi, ukuran, orientasi, dan warna.Anda dapat menggunakan bagian dasar apa adanya, atau Anda dapat menerapkan operasi [modeling solid](/docs/id-id/parts/solid-modeling) untuk menggabungkan bagian menjadi bentuk yang lebih kompleks.
Untuk model 3D canggih dan rumit, Anda juga dapat mengimpor file model pihak ketiga sebagai [MeshParts](/docs/id-id/reference/engine/classes/MeshPart) seperti yang dijelaskan di [Meshes](/docs/id-id/parts/meshes).
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Basic-Part-Sphere.png' alt='A single gray sphere part' title='' width='100%' height='' />
*Bagian bola dasar*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Part-Example-CSG.jpg' alt='A bright blue hollow bowl that was made with solid modeling operations.' title='' width='100%' height='' />
*Mangkuk dibuat dengan pemodelan padat*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Mesh-Example.jpg' alt='A high-quality treasure chest mesh with a texture.' title='' width='100%' height='' />
*Mesh dengan tekstur*
Secara default, bagian adalah tubuh kaku yang mengikuti mekanika fisik dunia nyata, termasuk gravitasi, tabrakan, dan momentum.Anda dapat menghubungkan bagian terkait bersama sebagai satu [montase](/docs/id-id/physics/assemblies) menggunakan [WeldConstraint](/docs/id-id/reference/engine/classes/WeldConstraint) , atau bergabung seperti [Motor6D](/docs/id-id/reference/engine/classes/Motor6D) atau [Bone](/docs/id-id/reference/engine/classes/Bone) .Sebagai sebuah kumpulan, bagian yang terhubung bertindak sebagai entitas tunggal yang kaku, merujuk pada posisi, orientasi, dan skala umum.
Anda dapat menggunakan wadah [Model](/docs/id-id/reference/engine/classes/Model) untuk mengumpulkan bagian terkait bersama\-sama dan mengakses kelompok sebagai satu kumpulan di [Explorer](/docs/id-id/studio/explorer).Lihat [Model](/docs/id-id/parts/models) untuk informasi lebih lanjut.
## [Tipe Bagian Dasar](#tipe-bagian-dasar)
[Part](/docs/id-id/reference/engine/classes/Part) objek dapat mengambil bentuk blok, bola, silinder, balok sudut, atau balok sudut.Selain itu, [TrussPart](/docs/id-id/reference/engine/classes/TrussPart) bertindak sebagai rangka batang yang karakter dapat panjat seperti tangga.
*Blok*
*Bola*
*Silinder*
*Pasak*
*Pasak Sudut*
## [Properti bagian](#properti-bagian)
Setiap bagian memiliki berbagai properti yang dapat Anda kustomisasi melalui jendela [Properti](/docs/id-id/studio/properties).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Sections-Example.png' alt='A close up view of the Properties window with the Appearance and Transform properties highlighted.' title='' width='320' height='' />Berikut adalah properti yang umumnya digunakan:
* [Anchored](/docs/id-id/reference/engine/classes/BasePart) mengontrol jika fisika mempengaruhi posisi bagian.Ketika properti ini diatur ke benar, bagian tidak pernah berubah posisi karena gravitasi atau kekuatan lainnya.Anda harus mengaitkan sebagian besar bagian dalam pengalaman atau gravitasi dan fisika akan mempengaruhi bagian Anda segera setelah pengalaman berjalan.
Untuk melihat garis bercahaya di sekitar dasar bagian yang diikat untuk memvisualisasikan bagian mana yang tidak dapat bergerak di bawah gravitasi atau fisika, nyalakan bagian yang diikat dari widget [Opsi Visualisasi](/docs/id-id/studio/ui-overview#visualization-options) di sudut kanan atas tampilan 3D.
* [CanCollide](/docs/id-id/reference/engine/classes/BasePart) mengontrol apakah suku bagian dapat bertabrakan dengan bagian lain atau tidak.Ketika properti ini diatur ke benar, bagiannya tidak dapat ditembus dan mesin fisika menyertakannya dalam pengalaman Anda.Sebaliknya, ketika properti ini diatur ke false, bagian dapat melewati apa pun, dan mesin fisika tidak tidak mempertimbangkann hal itu.
* [Transparency](/docs/id-id/reference/engine/classes/BasePart) menetapkan visibilitas bagian ke nilai apa pun di antara nilai default 0 (terlihat penuh) dan 1 (terlihat penuh).Jika Anda memiliki banyak bagian parsial transparan, mereka dapat memperlambat pelaksanaan.Untuk meringankan ini, gabungkan mereka menggunakan [modeling solid](/docs/id-id/parts/solid-modeling) .
## [Sisipkan bagian](#sisipkan-bagian)
Tombol Bagian memasukkan bagian baru ke dalam ruang kerja.Mengklik panah dropdown kecil di tombol memungkinkan Anda memilih antara Blok , Sfera , Pasak , Sudut Wedge , atau Silinder .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Part-Tools.png' alt='Studio's Model tab with the Insert Part tool and its Part Type Picker highlighted.' title='' width='660' height='' />Untuk menyisipkan [TrussPart](/docs/id-id/reference/engine/classes/TrussPart) (tidak tersedia di menu sisipan), gunakan [Explorer](/docs/id-id/studio/explorer) seperti yang dijelaskan [di sini](/docs/id-id/studio/explorer#insert-and-parent) .
## [Pilih bagian](#pilih-bagian)
Saat Anda mengarahkan kursor ke bagian di jendela, mereka disorot untuk menunjukkan pilihan potensial mereka.Anda dapat memilih bagian yang ditentukan dengan mengkliknya, atau Anda dapat memilih beberapa bagian dengan menahan Shift , Ctrl , atau ⌘ saat Anda mengarahkan dan mengkliknya.Lihat [di sini](/docs/id-id/studio/ui-overview#object-selection) untuk metode lanjutan memilih bagian dalam tampilan 3D.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Editor-Window-Object-Selection.jpg' alt='Multiple models selected in 3D viewport' title='' width='800' height='' />
## [Transformasi bagian](#transformasi-bagian)
Anda dapat memindahkan, memperbesar, dan memutar bagian yang dipilih melalui alat model atau dengan menetapkan posisi, ukuran, atau orientasi baru di jendela [Properti](#part-properties).
Saat menggunakan alat, Anda dapat memindahkan, memperbesar, atau memutar bagian di orientasi dunia atau lokal dengan menekan di Windows atau di Mac.Ketika Anda mengaktifkan orientasi lokal, indikator sumbu panah berubah menjadi orientasi lokal bagian, dan indikator L ditampilkan.
Dunia
Lokal
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Move-World-Orientation.png' alt='An angled block part with draggers in World orientation mode.' title='' width='720' height='405' />
### [Pindah](#pindah)
Anda dapat memindahkan bagian yang dipilih ke posisi baru menggunakan alat Pindahkan (jalan pintas default 2 ) atau dengan seretan kurator .Saat memindahkan bagian, Anda dapat sementara menyalakan [geser](/docs/id-id/studio/model-tab#transform-snapping) dengan menahan Shift.
Alat Pindah
Drag Kursor
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Transform-Tool-Move.png' alt='Studio toolbar with the Move tool highlighted.' title='' width='562' height='' />
Untuk memindahkan bagian dengan penggeser sumbu di sepanjang X , Y , atau Z sumbu, klik/seret panah yang menunjuk ke sumbu gerakan yang diinginkan.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Move.png' alt='A block part with the Move tool's visual aids.' title='' width='720' height='' />Setelah melepaskan seretan, indikator jarak numerik tetap terlihat .Jika diinginkan, sesuaikan jarak yang dipindahkan dengan mengklik di dalam indikator dan memasukkan nomor apa pun.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Move-Indicator.png' alt='A moved part showing the distance moved in an indicator/input field' title='' width='720' height='' />Jika Anda menyeret bagian dengan titik [pivot](/docs/id-id/studio/pivot-tools) saat alat Pindahkan dipilih, pivot akan "melentingkan lembut" ke permukaan dan sudut bagian terdekat.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Move-Pivot-Snap.png' alt='A block part with an offset pivot soft-snapping to the surface of a nearby part.' title='' width='720' height='' />
### [Skalanya](#skalanya)
Untuk memperbesar (mengubah ukuran) bagian yang dipilih di sepanjang X , Y , atau Z sumbu, gunakan alat Skala (jalan pintas default 3 ) dan klik/seret penangan.Saat menyeret, Anda dapat sementara menyalakan [geser](/docs/id-id/studio/model-tab#transform-snapping) dengan menahan Shift .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Transform-Tool-Scale.png' alt='Studio toolbar with the Scale tool highlighted.' title='' width='562' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Scale.png' alt='A block part with the Scale tool's visual aids.' title='' width='720' height='' />
### [Memutar](#memutar)
Untuk memutar bagian yang dipilih di sekitar X , Y , atau Z sumbu, gunakan alat Putar (jalan pintas default 4 ) dan klik/seret cincin rotasi.Saat menyeret, Anda dapat sementara menyalakan [geser](/docs/id-id/studio/model-tab#transform-snapping) dengan menahan Shift .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Transform-Tool-Rotate.png' alt='Studio toolbar with the Rotate tool highlighted.' title='' width='562' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Transform-Rotate.png' alt='A block part with the Rotate tool's visual aids.' title='' width='720' height='' />
## [Bagian warna](#bagian-warna)
Sementara bagian adalah abu\-abu secara default, Anda dapat mengubahnya menjadi warna apa pun melalui metode berikut.
### [Peta segi enam](#peta-segi-enam)
Mengklik panah dropdown kecil di warna widget mengungkapkan pemilih warna hexagonal.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Color-Picker.png' alt='Studio's Model tab with the Color widget's hexagonal picker.' title='' width='704' height='' />Secara default, mengklik tombol keseluruhan Warna menerapkan warna yang dipilih ke setiap bagian dipilih .Jika Anda lebih suka menggunakan alur kerja isi/cat, nyalakan Aksi Warna sebagai Alat dan kemudian klik bagian di jendela 3D untuk menerapkan warna yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Color-Action-As-Tool.png' alt='Studio's Model tab with the Color Action as Tool selector indicated.' title='' width='704' height='' />
### [pop\-upwarna](#pop-upwarna)
Popup Warna memungkinkan Anda untuk mengatur warna melalui widget pemilih warna sistem operasi Anda.Untuk mengaksesnya, navigasikan ke jendela [Properti](/docs/id-id/studio/properties) dan klik kotak kecil di sebelah kiri properti [Color](/docs/id-id/reference/engine/classes/BasePart#Color).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Color-Picker.png' alt='A close up view of the Properties window with the Color property's color box highlighted.' title='' width='320' height='' />
### [Nilai RGB](#nilai-rgb)
Untuk mendefinisikan nilai warna RGB tertentu untuk suku cadang, masukkan nilai RGB ke dalam bidang properti [Color](/docs/id-id/reference/engine/classes/BasePart#Color).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Color-RGB-Entry.png' alt='A close up view of the Properties window with the Color property's RGB color value highlighted.' title='' width='320' height='' />
## [Terapkan bahan](#terapkan-bahan)
Mirip dengan [warna](#color-parts) , Anda dapat menyesuaikan materi bagian untuk meniru materi dunia nyata seperti kayu, kaca, atau kain.Saat memilih material, pertimbangkan hal mengikuti:
* Bahan mempengaruhi ciri fisik suku cadang, bukan hanya penampilannya .Sebagai contoh, material Beton lebih berat dari material Plastik , jadi batu bata beton akan memiliki densitas lebih tinggi daripada batu bata plastik dan tenggelam di air lebih cepat.
* Beberapa materi memiliki efek fisik khusus. Misalnya, bagian akan tampak bersinar jika diatur ke materi Neon .
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Material-SmoothPlastic.png' alt='An angled red block part with a smooth plastic material.' title='' width='100%' height='' />
*Plastik Mulus*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/parts/Material-Neon.png' alt='An angled red block part with a glowing neon material.' title='' width='100%' height='' />
*Neon*
Lihat [Bahan](/docs/id-id/parts/materials) untuk informasi lebih lanjut tentang cara menerapkan kedua bahan default dan kustom ke bagian.
| 88 |
https://create.roblox.com/docs/id-id/parts/solid-modeling
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
6. /
7. [Bagian](/docs/id-id/parts)
Bahasa Indonesia
Masukan
# Modelingsolid
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/parts/solid-modeling).
Pemodelan padat adalah proses bergabung [bagian](/docs/id-id/parts) bersama\-sama dengan cara unik untuk membentuk bentuk yang lebih kompleks yang dikenal sebagai serikat atau persimpangan .Anda dapat melakukan empat operasi pemodelan solid menggunakan alat di tab Model dalam bilah alat.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Solid-Modeling.png' alt='Studio's Model tab with the Solid Modeling tools highlighted.' title='' width='732' height='' />
| Alat | Jalan pintas | Deskripsi |
| --- | --- | --- |
| [Persatuan](#union-parts) | ShiftCtrlG (Windows) Shift⌘G (Mac) | Bergabung dua atau lebih bagian bersama untuk membentuk satu persatuan padat tunggal. |
| [Terpotong](#intersect-parts) | ShiftCtrlI (Windows) Shift⌘I (Mac) | Menyilangkan bagian tumpang tindih ke dalam satu persimpangan padat. |
| [Menolak](#negate-parts) | ShiftCtrlN (Windows) Shift⌘N (Mac) | Tolak bagian, berguna untuk membuat lubang dan indentasi. |
| [Terpisah](#separate-unions-or-intersections) | ShiftCtrlU (Windows) Shift⌘U (Mac) | Pisahkan serikat atau persimpangan kembali ke bagian\-bagian individunya. |
## [Bagian serikat](#bagian-serikat)
Alat Uni bergabung dengan dua atau lebih bagian bersama untuk membentuk satu solid [UnionOperation](/docs/id-id/reference/engine/classes/UnionOperation).Secara default, serikat baru menghormati properti [Color](/docs/id-id/reference/engine/classes/BasePart#Color) dari masing\-masing bagiannya, meskipun Anda dapat mengaktifkan properti [UsePartColor](/docs/id-id/reference/engine/classes/PartOperation#UsePartColor) untuk mengubah seluruh serikat ke warna tertentu.
Bagian Terpisah
Bergabung
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg' alt='Block and cylinder parts overlapping' title='' width='720' height='375' />Untuk menggabungkan bagian bersama\-sama menjadi serikat:
1. Pilih semua bagian yang ingin Anda gabungkan bersama.
2. Klik tombol Union . Semua bagian bergabung menjadi satu solid [UnionOperation](/docs/id-id/reference/engine/classes/UnionOperation) dengan nama Union .
## [Interseks bagian](#interseks-bagian)
Alat Intersect memotong bagian tumpang tindih ke dalam satu solid [IntersectOperation](/docs/id-id/reference/engine/classes/IntersectOperation) .Secara default, warna wajah dari persimpangan hasil dipinjam dari properti [Color](/docs/id-id/reference/engine/classes/BasePart#Color) dari bagian asli, meskipun Anda dapat mengaktifkan properti [UsePartColor](/docs/id-id/reference/engine/classes/PartOperation#UsePartColor) untuk mengubah seluruh persimpangan menjadi warna tertentu.
Bagian Terpisah
Terpotong
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg' alt='Block and cylinder parts overlapping' title='' width='720' height='375' />
Untuk menyilangkan bagian tumpang tindih bersama:
1. Pilih semua bagian yang ingin Anda interseksikan.
2. Klik tombol Intersect . Semua bagian bergabung menjadi satu solid [IntersectOperation](/docs/id-id/reference/engine/classes/IntersectOperation) dengan nama Intersection .
## [Tolak bagian](#tolak-bagian)
Alat Menyangkal menyangkal bagian sehingga ketika digabungkan dengan bagian lain, bentuk bagian yang dieliminasi dikurangi dari bagian lain.
Bagian Terpisah
Dibantah
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/solid-modeling/Negated-Part-To-Union.jpg' alt='Negated block overlapping a cylinder' title='' width='720' height='375' />
Untuk mengurangkan bagian dari bagian tumpangan lain:
1. Pilih bagian yang ingin Anda singkirkan dari bagian lain.
2. Klik Menyangkal . Bagian menjadi [NegateOperation](/docs/id-id/reference/engine/classes/NegateOperation) dengan nama Bagian Negatif dan berubah menjadi merah muda dan transparan untuk menunjukkan statusnya.
3. Pilih bagian yang dibatalkan dan bagian yang ingin Anda kurangi dari.
4. Klik Union . Bagian yang dibatalkan dipotong dari bagian tumpangan yang termasuk.
## [Serikat terpisah atau persimpangan](#serikat-terpisah-atau-persimpangan)
Alat Terpisah memisahkan kembali sebuah [UnionOperation](/docs/id-id/reference/engine/classes/UnionOperation) ke dalam bagian\-bagiannya masing\-masing, pada dasarnya berfungsi sebagai alat "membatalkan" untuk serikat dan persimpangan.
Untuk memisahkan serikat atau persimpangan kembali ke bagian\-bagian individu:
1. Pilih serikat atau persimpangan.
2. Klik Terpisah . Bagian\-bagian terpisah kembali ke bentuk aslinya.
## [Render kesetiaan](#render-kesetiaan)
Secara default, operasi model solid baru akan selalu ditampilkan dalam render fidelitas [Automatic](/docs/id-id/reference/engine/enums/RenderFidelity#Automatic), yang berarti rincian bagian didasarkan pada jaraknya dari kamera seperti yang dijelaskan dalam tabel berikut.
| Jarak dari kamera | Render kesetiaan |
| --- | --- |
| Kurang dari 250 kancing | Tertinggi |
| 250\-500 kancing | Sedang |
| 500 atau lebih kancing | Terendah |
## [Sudut mengkilap](#sudut-mengkilap)
Properti bagian berbentuk solid yang dimodelkan [SmoothingAngle](/docs/id-id/reference/engine/classes/PartOperation#SmoothingAngle) memperhalus sudut antara permukaan berdekatan dari warna atau bahan yang sama.Nilai yang lebih tinggi menghasilkan penampilan yang lebih halus sementara nilai yang lebih rendah menghasilkan penampilan yang lebih kasar dengan lebih banyak tepi tajam.
Sementara nilai antara 30 dan 70 derajat biasanya menghasilkan hasil yang baik, nilai antara 90 dan 180 tidak direkomendasikan karena dapat menyebabkan efek "pencahayaan" pada serikat dan persimpangan dengan tepi tajam.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/solid-modeling/CSG-SmoothingAngle-0.jpg' alt='Solid modeled part with SmoothingAngle of 0' title='' width='100%' height='' />
*[SmoothingAngle](/docs/id-id/reference/engine/classes/PartOperation#SmoothingAngle) \= 0*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/solid-modeling/CSG-SmoothingAngle-50.jpg' alt='Solid modeled part with SmoothingAngle of 50' title='' width='100%' height='' />
*[SmoothingAngle](/docs/id-id/reference/engine/classes/PartOperation#SmoothingAngle) \= 50*
## [Pemodelan solid dalam Modeling](#pemodelan-solid-dalam-modeling)
Selain dari Union , Intersect , dan Menyangkal alat di Studio, Anda dapat mengizinkan pemain menggunakan operasi pemodelan solid saat berada di dalam pengalaman melalui [UnionAsync()](/docs/id-id/reference/engine/classes/BasePart#UnionAsync) , [IntersectAsync()](/docs/id-id/reference/engine/classes/BasePart#IntersectAsync) , dan [SubtractAsync()](/docs/id-id/reference/engine/classes/BasePart#SubtractAsync).Semua metode ini harus dipanggil pada [BasePart](/docs/id-id/reference/engine/classes/BasePart) dan mereka semua memerlukan array dari satu atau lebih bagian untuk bersatu, berinteraksi, atau dikurangi dari bagian yang dipanggil.
Operasi pemodelan padat dalam pengalaman tidak sinkron, artinya mereka dapat memengaruhi pelaksanaan.Untuk hasil terbaik, Anda tidak harus melakukan serangkaian besar dari [UnionAsync()](/docs/id-id/reference/engine/classes/BasePart#UnionAsync) , [IntersectAsync()](/docs/id-id/reference/engine/classes/BasePart#IntersectAsync) , atau [SubtractAsync()](/docs/id-id/reference/engine/classes/BasePart#SubtractAsync) panggilan dalam urutan singkat.
Saat mengeksekusi operasi [UnionAsync()](/docs/id-id/reference/engine/classes/BasePart#UnionAsync) , [IntersectAsync()](/docs/id-id/reference/engine/classes/BasePart#IntersectAsync) , atau [SubtractAsync()](/docs/id-id/reference/engine/classes/BasePart#SubtractAsync) , properti berikut dari bagian panggil diterapkan ke sindikat hasil: [Color](/docs/id-id/reference/engine/classes/BasePart#Color) , [Material](/docs/id-id/reference/engine/classes/BasePart#Material) , [MaterialVariant](/docs/id-id/reference/engine/classes/BasePart#MaterialVariant) , [Reflectance](/docs/id-id/reference/engine/classes/BasePart#Reflectance) , [Transparency](/docs/id-id/reference/engine/classes/BasePart#Transparency) , [Anchored](/docs/id-id/reference/engine/classes/BasePart#Anchored) , [CanCollide](/docs/id-id/reference/engine/classes/BasePart#CanCollide) , [Density](/docs/id-id/reference/engine/classes/BasePart#Density) , [Elasticity](/docs/id-id/reference/engine/classes/BasePart#Elasticity) , [ElasticityWeight](/docs/id-id/reference/engine/classes/BasePart#ElasticityWeight) , [Friction](/docs/id-id/reference/engine/classes/BasePart#Friction) , dan [FrictionWeight](/docs/id-id/reference/engine/classes/BasePart#FrictionWeight) .
### [UnionAsync()](#unionasync)
Untuk menunjukkan , berikut adalah menggunakan Bagian1 dari ruang kerja, menggabungkannya dengan Bagian2 , Bagian3 , dan Bagian4 , kemudian orangtuanya ke ruang kerja pada posisi asli dari Bagian1 .
```
---
```
local Workspace = game:GetService("Workspace")
local mainPart = Workspace.Part1
local otherParts = {Workspace.Part2, Workspace.Part3, Workspace.Part4}
-- Lakukan operasi persatuan
local success, newUnion = pcall(function()
return mainPart:UnionAsync(otherParts)
end)
-- Jika operasi berhasil, posisikan di lokasi yang sama dan berikan ke ruang kerja
if success and newUnion then
newUnion.Position = mainPart.Position
newUnion.Parent = Workspace
end
-- Hancurkan bagian asli yang tetap utuh setelah operasi
mainPart:Destroy()
for _, part in otherParts do
part:Destroy()
end
```
```
### [Interseksi Async()](#interseksi-async)
Untuk menunjukkan , berikut menggunakan Bagian1 dari ruang kerja, melintasi dengan Bagian2 dan Bagian3 , kemudian orang tua hasilnya ke ruang kerja di posisi asli dari Bagian1 .
```
---
```
local Workspace = game:GetService("Workspace")
local mainPart = Workspace.Part1
local otherParts = {Workspace.Part2, Workspace.Part3}
-- Lakukan operasi intersepsi
local success, newIntersect = pcall(function()
return mainPart:IntersectAsync(otherParts)
end)
-- Jika operasi berhasil, posisikan di lokasi yang sama dan berikan ke ruang kerja
if success and newIntersect then
newIntersect.Position = mainPart.Position
newIntersect.Parent = Workspace
end
-- Hancurkan bagian asli yang tetap utuh setelah operasi
mainPart:Destroy()
for _, part in otherParts do
part:Destroy()
end
```
```
### [Subtraksi Async()](#subtraksi-async)
Untuk menunjukkan , berikut menggunakan Bagian1 dari ruang kerja, menyangkal Bagian2 , Bagian3 , dan Bagian4 dari itu, kemudian orang tua hasilnya ke ruang kerja di posisi asli dari Bagian1 .
```
---
```
local Workspace = game:GetService("Workspace")
local mainPart = Workspace.Part1
local otherParts = {Workspace.Part2, Workspace.Part3, Workspace.Part4}
-- Lakukan operasi kurang
local success, newSubtract = pcall(function()
return mainPart:SubtractAsync(otherParts)
end)
-- Jika operasi berhasil, posisikan di lokasi yang sama dan berikan ke ruang kerja
if success and newSubtract then
newSubtract.Position = mainPart.Position
newSubtract.Parent = Workspace
end
-- Hancurkan bagian asli yang tetap utuh setelah operasi
mainPart:Destroy()
for _, part in otherParts do
part:Destroy()
end
```
```
| 89 |
https://create.roblox.com/docs/id-id/parts/textures-decals
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
6. /
7. [Bagian](/docs/id-id/parts)
Bahasa Indonesia
Masukan
# Tekstur dan dekal
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/parts/textures-decals).
A [Texture](/docs/id-id/reference/engine/classes/Texture) adalah gambar yang dapat Anda tempatkan di wajah mana pun dari [bagian](/docs/id-id/parts) atau [persatuan](/docs/id-id/parts/solid-modeling) yang diulang baik secara horizontal maupun vertikal pada ukuran permukaan.Sebaliknya, [Decal](/docs/id-id/reference/engine/classes/Decal) adalah gambar yang memanjang untuk menyesuaikan area permukaan bagian atau serikat.Setelah Anda menambahkan objek [Texture](/docs/id-id/reference/engine/classes/Texture) atau [Decal](/docs/id-id/reference/engine/classes/Decal) ke bagian atau sindikat, Anda dapat:
* Ubah properti tekstur atau decal [Color3](/docs/id-id/reference/engine/classes/Decal#Color3) untuk mengatur tinta warna menggunakan kode warna RGB.
* Ubah properti tekstur atau decal [Transparency](/docs/id-id/reference/engine/classes/Decal#Transparency) ke nilai antara default dari 0 (terlihat penuh) dan 1 (tidak terlihat).
* Untuk teksur, atur skalanya dan offsetnya .
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Decal-Texture-Sample-2.png' alt='An example texture image of a light blue hexagon on top of a dark blue background.' title='' width='63%' height='' />
*Gambar tekstur*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-On-Surface.jpg' alt='The same blue texture repeated eight times on a block part.' title='' width='100%' height='' />
*Tekstur yang diterapkan ke bagian (diulang)*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Decal-Texture-Sample-1.png' alt='An example decal image of a light purple hexagon on top of a dark purple background.' title='' width='63%' height='' />
*Gambar dekal*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Decal-On-Surface.jpg' alt='The same purple decal stretched on the top face of a block part.' title='' width='100%' height='' />
*Stiker diterapkan ke bagian (diperpanjang)*
## [Buat tekstur atau stiker](#buat-tekstur-atau-stiker)
Untuk membuat teks atau stiker, Anda harus menambahkan entitas [Texture](/docs/id-id/reference/engine/classes/Texture) atau [Decal](/docs/id-id/reference/engine/classes/Decal) ke bagian atau persatuan.Anda dapat [导入](/docs/id-id/projects/assets/manager#asset-import) gambar untuk tekstur dan stiker ke Studio untuk digunakan di antara pengalaman, dan [distribusikan](/docs/id-id/production/creator-store) ke [Toko Pencipta](/docs/id-id/production/creator-store).Setelah Anda mengimpor gambar, Studio menugaskannya ID aset unik.
Setiap teks atau gambar decal yang Anda buat dan impor ke Roblox harus mematuhi Aturan Komunitas dan Syarat Penggunaan .
Untuk menambahkan tekstur atau stiker ke bagian atau serikat:
1. Di jendela Explorer , tambahkan [Texture](/docs/id-id/reference/engine/classes/Texture) atau [Decal](/docs/id-id/reference/engine/classes/Decal) ke bagian atau serikat:
1. Pasang mouse di atas bagian atau serikat dan klik tombol ⊕. Menu konteks ditampilkan.
2. Dari menu, masukkan Tekstur atau Decal . Objek teks kosong atau decal ditampilkan di bagian atau persatuan dengan garis oranye.
2. Di jendela Properti , navigasikan ke properti Wajah dan [pilih wajah](#choose-a-face) atau pertahankan wajah default.
3. Pilih properti Tekstur dan terapkan gambar melalui salah satu metode berikut:
* Pilih tekstur atau stiker apa pun yang telah Anda unggah sebelumnya.
* Masukkan ID aset ke bidang Tekstur .
* Upload gambar baru melalui tombol Tambah Gambar... .
4. (Opsi) Tetapkan tinta warna dengan mengklik kotak kecil di sebelah kiri properti Color3 atau dengan memasukkan kode warna RGB.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Properties-Color3-Picker.png' alt='A close of view of the Color3 property with the small color box highlighted.' title='' width='320' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Properties-Color3-RGB-Entry.png' alt='A close of view of the Color3 property with the RGB code highlighted.' title='' width='320' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-On-Surface.jpg' alt='A block part with a repeating blue hexagon texture on its top face.' title='' width='100%' height='' />
*Standar*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Color3-255-0-100.jpg' alt='The same block part with a repeating hexagon texture on its top face, but the hexagons are pink against on dark purple background.' title='' width='100%' height='' />
*Warna3 \= \[255, 0, 100]*
5. (Opsi) Tetapkan properti Transparansi ke nilai apa pun di antara nilai default dari 0 (terlihat penuh) dan 1 (tidak terlihat).
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-On-Surface.jpg' alt='A block part with a repeating blue hexagon texture on its top face.' title='' width='100%' height='' />
*Standar*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Transparency-0.4.jpg' alt='The same block part with a repeating hexagon texture on its top face, but the hexagons are semi-transparent.' title='' width='100%' height='' />
*Transparansi \= 0\.6*
### [Pilih wajah](#pilih-wajah)
Wajah adalah permukaan pada bagian/persatuan yang menampilkan tekstur atau stiker: Atas , Bawah , Depan , Belakang , Kiri , atau Kanan .Arah setiap wajah tergantung pada orientasi bagian atau serikat.Dalam gambar contoh berikut, kamera menghadap wajah blok Depan , sehingga wajah kiri blok Tersisa berada di sebelah kanan dari perspektif kamera.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Face-Front.jpg' alt='A block part with a texture that displays on the block's front face. The Show Orientation Indicator highlights the block's front face orientation.' title='' width='100%' height='' />
*Depan*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Face-Top.jpg' alt='A block part with a texture that displays on the block's top face. The Show Orientation Indicator highlights the block's front face orientation.' title='' width='100%' height='' />
*Atas*
Untuk memilih wajah:
1. (Opsi) Untuk membantu dalam memilih wajah yang benar, klik kanan bagian/uni dan pilih Tampilkan Indikator Orientasi .Ini menampilkan lingkaran biru dengan F dan garis yang terpasang pada wajah Depan objek, dan panah hijau yang menunjuk ke arah wajah objek Atas .
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Orientation-Indicator.jpg' alt='' title='' width='600' height='' />
2. Pilih tekstur atau stiker yang merupakan anak dari bagian atau serikat.
3. Di jendela Properti , klik properti Wajah dan pilih wajah.
## [Kustomisasi tekstur](#kustomisasi-tekstur)
Tidak seperti stiker, tekstur memberikan fungsi lebih lanjut untuk skala, kompensasi, dan animasi gambar.
### [Skala teksur](#skala-teksur)
Ukuran bagian tidak mempengaruhi tekstur. Sebaliknya, skala bagian hanya meningkatkan atau menurunkan jumlah kali tekstur diulang.
Properti [StudsPerTileU](/docs/id-id/reference/engine/classes/Texture#StudsPerTileU) dan [StudsPerTileV](/docs/id-id/reference/engine/classes/Texture#StudsPerTileV) menentukan ukuran masing\-masing "ujung" dalam stud.[StudsPerTileU](/docs/id-id/reference/engine/classes/Texture#StudsPerTileU) menentukan ukuran horizontal teksur saat [StudsPerTileV](/docs/id-id/reference/engine/classes/Texture#StudsPerTileV) menentukan ukuran vertikal teksur.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Decal-Texture-Sample-2.png' alt='An example texture image of a light blue hexagon on top of a dark blue background.' title='' width='100%' height='' />
*Gambar Tekstur*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Sample-UV-1.png' alt='The same texture on a surface of 8x6 studs with size of each tile in 2x2.' title='' width='100%' height='' />
*Permukaan 8×6 Studs*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Sample-UV-2.png' alt='The same texture on a surface of 8x6 studs with size of each tile in 4x4.' title='' width='100%' height='' />
*Permukaan 8×6 Studs*
Untuk membesarkan tekstur:
1. Pilih teksur yang merupakan anak dari bagian.
2. Di jendela Properti , atur StudsPerTileU dan StudsPerTileV ke jumlah stud yang ingin Anda gunakan teksturnya secara horizontal dan vertikal.Semakin besar angkanya, semakin besar gambarnya.
### [Menghapus teksur offset](#menghapus-teksur-offset)
Jika Anda ingin lebih banyak kontrol atas posisi tekstur, kurangi tekstur dengan menyesuaikan properti [OffsetStudsU](/docs/id-id/reference/engine/classes/Texture#OffsetStudsU) dan [OffsetStudsV](/docs/id-id/reference/engine/classes/Texture#OffsetStudsV).Ini juga berguna untuk [animasi](#animate-textures).
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Decal-Texture-Sample-2.png' alt='An example texture image of a light blue hexagon on top of a dark blue background.' title='' width='100%' height='' />
*Gambar tekstur*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Sample-Offset-1.png' alt='The same texture on a surface of 8x6 studs with an offset of 1 stud.' title='' width='100%' height='' />
*Permukaan 8×6 Studs*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Texture-Sample-Offset-2.png' alt='The same texture on a surface of 8x6 studs with an offset of 1.5 studs.' title='' width='100%' height='' />
*Permukaan 8×6 Studs*
Untuk menyeimbangkan tekstur:
1. Pilih teksur yang merupakan anak dari bagian.
2. Di jendela Properti , atur OffsetStudsU dan OffsetStudsV ke jumlah stud yang ingin Anda offsetkan teksturnya secara horizontal dan vertikal.
### [Animasi teks](#animasi-teks)
Menggunakan [TweenService](/docs/id-id/reference/engine/classes/TweenService) , Anda dapat menyelipkan properti teksur seperti [OffsetStudsU](/docs/id-id/reference/engine/classes/Texture#OffsetStudsU) dan [StudsPerTileV](/docs/id-id/reference/engine/classes/Texture#StudsPerTileV) untuk mencapai permukaan beranimasi.Sebagai contoh, jika Anda menerapkan dua teksur kabut ke satu wadah dan menganimasinya dengan skrip berikut, Anda dapat mencapai penampilan kabut bergerak bertingkat:
[https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Animated-Textures.mp4](https://prod.docsiteassets.roblox.com/assets/modeling/textures-decals/Animated-Textures.mp4)
*Dua teks beranimasi di dekat lantai untuk menyimulasikan efek kabut bergerak*
```
---
```
local TweenService = game:GetService("TweenService")
local texture1 = script.Parent.Texture1
local texture2 = script.Parent.Texture2
local tweenInfo1 = TweenInfo.new(8, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1)
local tween1 = TweenService:Create(texture1, tweenInfo1, {OffsetStudsV=50})
local tweenInfo2 = TweenInfo.new(7, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true)
local tween2 = TweenService:Create(texture2, tweenInfo2, {OffsetStudsU=50, StudsPerTileU=55, StudsPerTileV=45})
tween1:Play()
tween2:Play()
```
```
| 90 |
https://create.roblox.com/docs/id-id/parts/meshes
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
Bahasa Indonesia
Masukan
# Gerobak
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/parts/meshes).
[MeshPart](/docs/id-id/reference/engine/classes/MeshPart) objek adalah keturunan kelas [BasePart](/docs/id-id/reference/engine/classes/BasePart).Mereka mewakili meshes , yang merupakan koleksi vertex, edge, dan wajah yang membentuk objek 3D.Tidak seperti bagian, yang dapat Anda buat langsung di Studio, Anda perlu menggunakan aplikasi pemodelan pihak ketiga seperti Blender atau Maya untuk membuat meshes, lalu impor ke Studio sebagai objek [MeshPart](/docs/id-id/reference/engine/classes/MeshPart).
Setelah menge导入网络 ke Studio, Anda dapat menyesuaikan properti renderingnya, seperti tekstur, tingkat rincian, dan keakuratan kolisi.Selain mem导入 mesh Anda sendiri, Anda juga dapat menelusuri dan memilih dari mesh yang diunggah oleh pengguna menggunakan [Toko Pencipta](/docs/id-id/production/creator-store).
Roblox mendukung banyak jenis meshes, selama mereka mematuhi spesifikasi meshes umum .Mesh dasar terdiri dari setidaknya satu objek mesh dan satu tekstur:
<img src='https://prod.docsiteassets.roblox.com/assets/art/Basic-Mesh-Example.png' alt='A tree mesh object without a texture.' title='' width='100%' height='' />
*Sebuah objek mesh menetapkan bentuk dan geometri objek 3D*
<img src='https://prod.docsiteassets.roblox.com/assets/art/Basic-Texture-Example.png' alt='The texture image map for the leaves of the tree in the previous image.' title='' width='100%' height='' />
*Peta gambar tekstur menerapkan penampilan dan warna permukaan*
<img src='https://prod.docsiteassets.roblox.com/assets/art/Basic-Mesh-Combined-Example.png' alt='A tree mesh object with the leaves texture applied.' title='' width='100%' height='' />
*Mesh dan tekstur bergabung untuk membuat objek 3D khusus yang unik*
Studio juga mendukung mesh dengan komponen untuk membuat model karakter avatar atau aksesori, seperti data [pengait dan kulit](#rigging-and-skinning).
Anda dapat menjual [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) aset sebagai tubuh avatar, aksesori, dan pakaian di Pasar. Lihat [Avatar](/docs/id-id/avatar) untuk informasi lebih lanjut.
## [Impor meshes](#impor-meshes)
Anda dapat menge导入 meshes ke Studio menggunakan [Importer 3D](/docs/id-id/art/modeling/3d-importer) .Dengan alat ini, Anda dapat melihat pratinjau dan memeriksa meshes sebelum menge导入nya ke ruang kerja atau Toolbox Anda, seperti memverifikasi tekstur, pengaitan, kulit, dan data animasi.Ini juga menandai masalah dan menolak meshes dengan kesalahan.
Jika file mesh yang Anda impor berisi objek menggunakan konvensi nama khusus atau berisi data animasi wajah, Impor 3D secara otomatis mendeteksi dan mengubahnya menjadi objek berikut ini bukan [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) :
* [Attachment](/docs/id-id/reference/engine/classes/Attachment) — Objek dengan \_Att di akhir nama mereka.
* [WrapTarget](/docs/id-id/reference/engine/classes/WrapTarget) — Objek dengan \_OuterCage di akhir nama mereka.
* [WrapLayer](/docs/id-id/reference/engine/classes/WrapLayer) — Objek dengan keduanya \_InnerCage\`\`\_OuterCage di akhir nama mereka.
* [FaceControls](/docs/id-id/reference/engine/classes/FaceControls) — Objek yang berisi kepala karakter avatar dan data animasi wajah yang sesuai.
Jika Anda ingin mengimpor meshes dalam jumlah banyak bersama dengan aset non\-3D, seperti gambar dan audio, Anda dapat menggunakan [Manajer Aset](/docs/id-id/projects/assets/manager) ; perhatikan, bagaimanapun, bahwa ia tidak mendukung impor meshes dengan rigging, skinning, dan data animasi, aksesori, atau karakter dengan animasi wajah.
## [Sesuaikan mesh](#sesuaikan-mesh)
Tidak seperti bagian dasar, meshes memiliki lebih banyak opsi kustomisasi yang dapat Anda sesuaikan untuk ketepatan rendering canggih.
### [Teksur](#teksur)
Tekstur menentukan penampilan visual meshes.Studio memungkinkan Anda untuk menerapkan satu teksur menggunakan properti [MeshPart.TextureID](/docs/id-id/reference/engine/classes/MeshPart#TextureID) atau menerapkan hingga empat teksur rendering berbasis fisik (PBR) dalam anak objek [SurfaceAppearance](/docs/id-id/reference/engine/classes/SurfaceAppearance) atau [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) anak objek mesh.Tekstur PBR memungkinkan Anda untuk mewakili bayangan dan pencahayaan realistis dengan menggunakan beberapa jenis gambar tekstur, atau peta, pada satu objek.
Teks PBR
Tekstur Tunggal
Studio mendukung empat peta tekstur PBR, masing\-masing sesuai dengan karakteristik visual penampilan permukaan objek.Menggabungkan beberapa peta tekstur dapat lebih akurat menyimulasikan warna, kasar, dan reflektivitas di setiap lingkungan pencahayaan, dan meningkatkan elemen visual dari aset dan lingkungan Anda.Untuk informasi lebih lanjut tentang teksur PBR dan peta teksur, lihat [PBR Textures](/docs/id-id/art/modeling/surface-appearance).
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/surface-appearance/SurfaceAppearance-Example-1.jpg' alt='' title='' width='100%' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/surface-appearance/SurfaceAppearance-Example-3.jpg' alt='' title='' width='100%' height='' />Anda dapat menerapkan teksur PBR menggunakan salah satu objek berikut:
* [SurfaceAppearance](/docs/id-id/reference/engine/classes/SurfaceAppearance) — Menerapkan teksur PBR ke permukaan mesh dan tidak memengaruhi geometrinya.
* [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) — Mewakili material khusus yang tidak hanya menerapkan teksur PBR ke permukaan mesh tetapi juga menambahkan properti fisik.
Untuk menambahkan teksur PBR ke mesh:
1. Di jendela Explorer , gulir di atas objek MeshPart.Klik tombol ⊕ dan pilih Penampilan Permukaan atau Material Varian .
2. Di jendela Properti , edit properti yang sesuai dengan peta tekstur PBR.
Jika Anda menambahkan keduanya [SurfaceAppearance](/docs/id-id/reference/engine/classes/SurfaceAppearance) dan [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) sebagai objek anak dari mesh, Studio hanya menerapkan pengaturan peta tekstur objek [SurfaceAppearance](/docs/id-id/reference/engine/classes/SurfaceAppearance) ke mesh.Mesh masih memiliki semua pengaturan lain dari objek [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) , seperti properti fisik khusus.
### [Tingkat detail](#tingkat-detail)
Anda dapat secara dinamis mengontrol tingkat rincian mesh menggunakan properti [Enum.RenderFidelity](/docs/id-id/reference/engine/enums/RenderFidelity) nya.Nilai default adalah [Automatic](/docs/id-id/reference/engine/enums/RenderFidelity#Automatic) , artinya rincian mesh didasarkan pada jaraknya dari kamera seperti yang dijelaskan dalam tabel berikut.
| Jarak dari kamera | Render kesetiaan | Contoh |
| --- | --- | --- |
| Kurang dari 250 kancing | Tertinggi | A potion mesh object that is rendered in the highest level of detail. |
| 250\-500 kancing | Sedang | A potion mesh object that is rendered in a medium level of detail. Its edges are more jagged than the previous image. |
| 500 atau lebih banyak stud | Terendah | A potion mesh object that is rendered in the lowest level of detail. Its edges are more jagged than the previous image, and the liquid is no longer shiny. |
### [Keandalan kolisi](#keandalan-kolisi)
Kesetiaan kolisi menentukan seberapa dekat representasi visual dari meshes cocok dengan batas fisiknya.Properti [MeshPart.CollisionFidelity](/docs/id-id/reference/engine/classes/MeshPart#CollisionFidelity) memiliki opsi berikut, dalam urutan ketepatan dan dampak kinerja dari terendah ke tertinggi:
* Kotak — Membuat kotak kolisi batas, ideal untuk objek kecil atau non\-interaktif.
* Hull — Menghasilkan hull konkav, cocok untuk objek dengan indelasi atau lubang yang kurang terlihat.
* Standar — Menghasilkan bentuk tabrakan yang kasar yang mendukung konkavitas, cocok untuk objek kompleks dengan kebutuhan interaksi semi terperinci.
* Pemecahan Konveks Akurat — Menawarkan kesetiaan paling akurat tetapi masih bukan representasi 1:1 dari visual.Opsi ini memiliki biaya kinerja paling mahal dan membutuhkan lebih lama bagi mesin untuk dihitung.
Mesh Asli
Standar
Kotak
Hubungan
Tepat
<img src='https://prod.docsiteassets.roblox.com/assets/physics/collisions/Collision-Fidelity-MeshPart.jpg' alt='Original mesh of castle tower' title='' width='600' height='500' />Untuk melihat keandalan kolisi di Studio, beralih pada keandalan kolisi dari widget [Opsi Visualisasi](/docs/id-id/studio/ui-overview#visualization-options) di sudut kanan atas tampilan 3D.
Untuk informasi lebih lanjut tentang dampak kinerja pada opsi keandalan kolisi dan cara mengatasinya, lihat [Tingkatkan kinerja](/docs/id-id/performance-optimization/improve#physics-computation).Untuk panduan mendalam tentang cara memilih opsi keandalan kolisi yang seimbang dengan persyaratan akurasi dan kinerja Anda, lihat [Atur parameter fisika dan rendering](/docs/id-id/tutorials/curriculums/environmental-art/optimize-your-experience#review-physics-and-rendering-parameters).
## [Rigging dan skinning](#rigging-dan-skinning)
Rigging adalah proses menghubungkan mesh dengan rangka skeleton internal yang dapat dioperasikan.Meshes rapuh memungkinkan permukaan meshes untuk berputar dan bergerak menggunakan tulang internal di dalam model, seperti lutut atau lengan karakter. Skinning jaring terikat memungkinkan objek jaring terikat untuk melengkung, meregang, dan melengkung dengan cara yang lebih realistis.
*Tanpa skinning, seluruh meshes kepala berputar pada satu sumbu*
*Dengan skinning, head mesh melengkung secara alami di leher, dan bagian bawah leher tetap terhubung ke torso*
Untuk informasi lebih lanjut tentang rigging dan skinning, lihat [Rigging dan skinning](/docs/id-id/art/modeling/rigging) .Setelah menyiapkan meshes, Anda dapat menambahkan animasi dan pose ke dalamnya menggunakan Editor Animasi.Lihat [Buat animasi](/docs/id-id/animation/editor#create-an-animation) untuk informasi lebih lanjut.Aset 3D pasar, seperti pakaian avatar dan tubuh, juga memerlukan rigging dan skinning.Lihat [Avatar](/docs/id-id/avatar) untuk informasi lebih lanjut tentang persyaratan untuk aset Pasar.
| 91 |
https://create.roblox.com/docs/id-id/parts/models
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
Bahasa Indonesia
Masukan
# Model
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/parts/models).
Model adalah wadah untuk objek fisik, seperti bagian, las, dan persambungan yang dapat Anda gunakan untuk mengatur ruang kerja dan menggrup aset Anda.Sementara model sering dapat berisi bagian terhubung, yang dikenal sebagai [montase](/docs/id-id/physics/assemblies) , model dapat berisi berapa pun bagian individu dan objek lain, seperti skrip, dan lampiran.
Karakter, seperti avatar atau NPC, adalah satu [Model](/docs/id-id/reference/engine/classes/Model) yang berisi bagian manusiawi yang tepat, sendi, dan komponen tambahan:
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/model-objects/Model-Example-3D.jpg' alt='An example character model of a humanoid monster girl in a dark purple dress.' title='' width='80%' height='' />
*Sebuah model bernama Octavia*
\>
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/model-objects/Model-Example-Hierarchy.png' alt='The groupings which comprise the Octavia model in Studio's Explorer window.' title='' width='68%' height='' />
*Kumpulan yang membentuk model*
\>
## [Buat model](#buat-model)
Ketika Anda menggrupkan objek bersama, mereka secara otomatis menjadi objek [Model](/docs/id-id/reference/engine/classes/Model).Namun, Anda juga dapat menyisipkan objek kosong [Model](/docs/id-id/reference/engine/classes/Model) ke Workspace, lalu secara manual menambahkan objek anak ke model.
Untuk membuat model menggunakan metode grup:
1. Di jendela Explorer atau 3D viewport, pilih setiap objek yang ingin Anda kumpulkan menjadi model.
2. Klik kanan pada salah satu objek dan pilih Grup , atau tekan Ctrl \+ G di Windows atau ⌘ \+ G di Mac.Objek baru [Model](/docs/id-id/reference/engine/classes/Model) ditampilkan dengan semua objek yang membentuk model yang disematkan di bawahnya.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/model-objects/Model-Group-Simple.png' alt='A close up view of the Explorer window. A Model object is highlighted with three nested children.' title='' width='320' height='' />
Untuk sepenuhnya melepaskan model kembali ke objek aslinya, klik kanan dan pilih Ungroup , atau tekan pada Windows atau pada Mac.
### [Tetapkan bagian utama](#tetapkan-bagian-utama)
Jika Anda memiliki model dengan bagian yang terhubung bersama melalui persambungan fisik seperti [WeldConstraints](/docs/id-id/reference/engine/classes/WeldConstraint) atau [Motor6Ds](/docs/id-id/reference/engine/classes/Motor6D) , Anda harus menentukan [BasePart](/docs/id-id/reference/engine/classes/BasePart) dalam model untuk menjadi [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) .Referensi fisik model adalah referensi fisik yang menentukan titik pivot dan kotak batas mana yang harus bergerak saat model berubah posisi atau orientasi.
Untuk mengatur bagian utama:
1. Di jendela Explorer , pilih model.
2. Di jendela Properti , pilih properti Bagian Utama . Kursor Anda berubah.
3. Kembali di jendela Explorer , pilih bagian yang ingin menjadi bagian utama Anda.
## [Pilih model](#pilih-model)
Saat Anda mengarahkan kursor ke model di jendela tampilan, mereka disoroti untuk menunjukkan pilihan potensial mereka.Anda dapat memilih model yang ditampilkan dengan mengkliknya, atau Anda dapat memilih beberapa model dengan menahan Shift , Ctrl , atau ⌘ saat Anda mengarahkan dan mengkliknya.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Editor-Window-Object-Selection.jpg' alt='A warehouse view in the 3D viewport. Multiple models are selected and highlighted with a light blue outline.' title='' width='800' height='' />Karena model biasanya berisi banyak bagian anak atau meshes , beberapa anak mungkin tersembunyi dari pandangan.Untuk memilih anak khusus tanpa memindahkan kamera atau menemukan anak di hierarki [Explorer](/docs/id-id/studio/explorer) , klik saat menahan Alt di Windows atau ⌥ di Mac untuk melakukan [seleksi siklus](/docs/id-id/studio/ui-overview#selection-cycling) .
[https://prod.docsiteassets.roblox.com/assets/studio/general/Selection-Cycling.mp4](https://prod.docsiteassets.roblox.com/assets/studio/general/Selection-Cycling.mp4)
*Siklus pemilihan*
## [Transformasi model](#transformasi-model)
Anda dapat memindahkan, memperbesar, atau memutar model menggunakan alat transformasi Studio di tab Rumah dan Model dalam bilah alat.Kecuali Anda telah mengatur bagian utama , model berubah berdasarkan pusat kotak pengikatnya.
Selain itu, dalam [Script](/docs/id-id/reference/engine/classes/Script) atau [LocalScript](/docs/id-id/reference/engine/classes/LocalScript), Anda dapat memindahkan atau memutar model melalui metode berikut:
| Metode | Deskripsi |
| --- | --- |
| [MoveTo()](/docs/id-id/reference/engine/classes/Model#MoveTo) | Pindahkan model [PrimaryPart](/docs/id-id/reference/engine/classes/Model#PrimaryPart) ke posisi yang diberikan. Jika bagian utama belum ditentukan, bagian akar model akan digunakan. |
| [PivotTo()](/docs/id-id/reference/engine/classes/PVInstance#PivotTo) | Mengubah model bersama dengan semua keturunannya [PVInstances](/docs/id-id/reference/engine/classes/PVInstance) sehingga pivot berlokasi di [CFrame](/docs/id-id/reference/engine/datatypes/CFrame) yang ditentukan. |
| [TranslateBy()](/docs/id-id/reference/engine/classes/Model#TranslateBy) | Bergeser model dengan offset yang diberikan [Vector3](/docs/id-id/reference/engine/datatypes/Vector3), menjaga orientasi model. |
## [Perilaku model](#perilaku-model)
Sementara model bertindak serupa dengan objek [Folder](/docs/id-id/reference/engine/classes/Folder) untuk sebagian besar tujuan dalam pengalaman Anda, mereka juga menunjukkan beberapa perilaku unik.
### [Model karakter](#model-karakter)
Ketika [Humanoid](/docs/id-id/reference/engine/classes/Humanoid) hadir di dalam model yang berisi [Part](/docs/id-id/reference/engine/classes/Part) bernama Kepala , Roblox menampilkan nama dan/atau bilah kesehatan di atas bagian itu.Untuk informasi lebih lanjut, lihat [Nama Karakter/Tampilan Kesehatan](/docs/id-id/characters/name-health-display).
<img src='https://prod.docsiteassets.roblox.com/assets/avatar/name-health-display/Display-Indicated.jpg' alt='Character display information above an in-experience avatar.' title='' width='800' height='' />
### [Hancurkan tinggi](#hancurkan-tinggi)
Untuk mencegah bagian yang telah jatuh dari peta pengalaman terus jatuh selamanya, Studio secara otomatis menghancurkan bagian yang jatuh di bawah nilai [Workspace.FallenPartsDestroyHeight](/docs/id-id/reference/engine/classes/Workspace#FallenPartsDestroyHeight).Jika bagian hancur karena perilaku ini adalah bagian terakhir dalam model, maka model itu juga akan hancur.
## [Pem streaming model](#pem-streaming-model)
Instansi [streaming](/docs/id-id/workspace/streaming) dinamis memuat dan melepaskan [Models](/docs/id-id/reference/engine/classes/Model) pada perangkat pemain saat karakter mereka menjelajahi dunia 3D.Dengan streaming diaktifkan, Anda dapat menentukan cara setiap model harus diperlakukan di bawah perilaku streaming.Sebagai contoh, model yang disetel ke [Persisten](/docs/id-id/workspace/streaming#persistent) tidak akan pernah diputar, atau model yang disetel ke [Atomik](/docs/id-id/workspace/streaming#atomic) akan diputar masuk dan keluar sebagai satu unit dengan semua keturunannnya.
Karena konten 3D yang ada di klien berubah secara dinamis dalam pengalaman yang diaktifkan streaming, model bisa tiba\-tiba menghilang.Untuk meringankan ini, Anda dapat menetapkan model spesifik untuk menyajikan sebagai meshes "impostor" dengan resolusi lebih rendah saat diputar, seperti yang dijelaskan di [Tingkat Model Detail](/docs/id-id/workspace/streaming#model-level-of-detail).
Lihat [Kontrol Streaming Model](/docs/id-id/workspace/streaming#model-streaming-controls) untuk lebih lanjut tentang kontrol streaming tingkat model.
## [Unggah model](#unggah-model)
Ketika Anda mengunggah atau mengimpor file model .gltf , .fbx dan .obj ke cloud menggunakan [Importer 3D](/docs/id-id/art/accessories/creating-rigid/importing) , Roblox mewakilinya sebagai aset berbasis cloud dengan ID yang unik.Sistem aset berbasis cloud ini memungkinkan Anda untuk menyimpan model melalui Roblox dan menggunakannya kembali di seluruh platform dalam berbagai konteks tanpa menyimpan salinan lokal sebagai bagian dari setiap pengalaman Studio yang disimpan.
Ada batasan 15\.000 ID aset unik yang dapat disebutkan dalam satu model.
Untuk mengunggah model yang Anda buat di Studio:
1. Di jendela Explorer , klik kanan model Anda. Menu konteks ditampilkan.
2. Pilih Simpan ke Roblox . Jendela Konfigurasi Aset ditampilkan.
3. Di jendela Konfigurasi Aset ,
1. Tetapkan Tipe Konten ke Item Pengembangan .
2. Tetapkan Kategori Aset menjadi Model .
3. Selesaikan bidang berikut:
* Judul \- Nama model Anda.
* Deskripsi \- Deskripsi singkat tentang model Anda.
* Pencipta \- Gunakan dropdown untuk memilih apakah Anda ingin menerbitkan aset ini sebagai individu atau sebagai bagian dari kelompok terkait.
* Jenis \- Jenis model Anda.
4. Klik tombol Simpan .Setelah beberapa saat, jendela Konfigurasi Aset menampilkan asetID model Anda yang dapat Anda gunakan dalam proyek Anda atau bagikan dengan pencipta lain, kelompok, atau pengalaman.Untuk informasi lebih lanjut tentang memberikan izin kepada kolaborator dan pengalaman sehingga mereka dapat menggunakan model Anda, lihat [Privasi aset](/docs/id-id/projects/assets/privacy)
## [Distribusikan model](#distribusikan-model)
Anda dapat mendistribusikan model ke [Toko Pencipta](/docs/id-id/production/creator-store) agar pencipta lain dapat menggunakannya dalam pengalaman mereka sendiri selama setiap model hanya merujuk:
* Buka aset penggunaan.
* Aset terbatas yang Anda buat, termasuk audio dan video.
* Aset gratis dari Toko Pencipta, termasuk audio dan video.
Setelah Anda mendistribusikan model, semua versi baru termasuk batasan yang sama bahkan jika Anda kemudian menghapusnya dari Toko Pencipta.
Jika Anda ingin mendistribusikan model dengan audio atau video aset anak yang Anda buat, Anda harus mendistribusikan aset audio atau video di Toko Pencipta sebelum menjadikannya anak model untuk audio atau video yang dapat didengar dan terlihat saat dijalankan.
Seperti dengan aset apa pun, semua model harus mematuhi Aturan Komunitas , Syarat Penggunaan , Panduan DMCA mengenai hak cipta dan Creator Store moderasi aset .Saat membuat model untuk Toko Pencipta:
* Baca tentang spesifikasi dan batasan teksur Roblox \>.
* Membatasi setiap mesh ke maksimum 20\.000 segi.
* Baca dan tangani peringatan apa pun yang ditampilkan selama proses impor.
* Skala dan orientasikan model Anda dengan tepat selama impor sehingga dapat digunakan keluar dari kotak saat dimasukkan dari Toko Pencipta.
Anda akan segera dapat menjual model di Toko Pencipta untuk Dolar Amerika Serikat (USD).Untuk informasi lebih lanjut dan mulai onboarding, lihat [Menjual di Toko Pencipta](/docs/id-id/production/sell-on-creator-store).
| 92 |
https://create.roblox.com/docs/id-id/parts/materials
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
Bahasa Indonesia
Masukan
# Bahan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/parts/materials).
Bahan Roblox tidak seperti bahan di platform lain, karena penampilan visual mereka dan properti fisik mereka mencerminkan properti bahan di dunia nyata.Sebagai contoh, beton lebih berat dari plastik dan tenggelam lebih cepat di dalam air.Ketika Anda menetapkan material dari bagian atau medan, Roblox menyimulasikan properti material fisiknya untuk membuat perilaku ini berfungsi.
Mesin Roblox menawarkan berbagai [material dasar](#base-materials) yang cocok untuk membangun banyak pengalaman, termasuk berbagai kategori logam, batu, dan bahan organik.
Anda juga dapat membuat bahan khusus Anda sendiri dan menerapkannya ke bagian atau medan .Bahan khusus memiliki perilaku [adaptif bahan](#adaptive-materials) tambahan yang memungkinkan Anda menyesuaikan model apa pun untuk menggunakan gaya seni dan bahan khusus Anda, bahkan jika orang lain membuat model.
## [Terapkan bahan](#terapkan-bahan)
Anda dapat dengan cepat menerapkan bahan ke [bagian](/docs/id-id/parts) melalui widget [Material](#material-widget).Manajer [Material](#material-manager) menawarkan fungsionalitas yang sama dan mode aplikasi "paint tool" tambahan.
### [widget materi](#widget-materi)
Widget Material dapat diakses dari tab Rumah atau Model di bilah alat.Mengklik panah dropdown kecil menunjukkan pemilih materi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Material-Picker.png' alt='Studio's Model tab with the Material widget's picker highlighted.' title='' width='704' height='' />Secara default, mengklik tombol keseluruhan Material menerapkan bahan yang dipilih ke setiap bagian terpilih .Jika Anda lebih suka menggunakan alur kerja isi/cat sebagai gantinya, nyalakan Tindakan Bahan sebagai Alat dan kemudian klik bagian di jendela 3D untuk menerapkan bahan yang dipilih.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Material-Action-As-Tool.png' alt='Studio's Model tab with the Material Action as Tool selector indicated.' title='' width='704' height='' />
### [Manajer materi](#manajer-materi)
Jika Anda telah mengaktifkan beta [Pemilih Bahan](#material-widget), akses Manajer Bahan dari jendela pemilih.Jika Anda belum mengaktifkan beta, temukan tombol khusus di sebelah kiri tombol Warna di bilah alat Rumah atau Model tab.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Material-Manager.png' alt='Studio's Model tab with the Material Manager button highlighted.' title='' width='704' height='' />Dari jendela manajer, Anda dapat menerapkan bahan ke [bagian](/docs/id-id/parts) melalui alur kerja berikut.
Terapkan ke Terpilih
Alat Lukis
Properti default [Enum.Material](/docs/id-id/reference/engine/enums/Material) untuk instans baru [Part](/docs/id-id/reference/engine/classes/Part) adalah Plastik . Untuk menerapkan bahan yang berbeda ke bagian:
1. Di jendela 3D atau [Explorer](/docs/id-id/studio/explorer), pilih satu atau lebih bagian.
2. Di palet Manajer Bahan , geser mouse Anda ke atas bahan yang diinginkan (Anda tidak perlu memilihnya) dan klik tombol Terapkan ke Bagian yang Dipilih .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Apply-To-Selected-Parts.png' alt='Apply to Selected Parts button indicated in Material Manager' title='' width='700' height='' />
## [Bahan khusus](#bahan-khusus)
Manajer [Material](#material-manager) memberikan antarmuka pengguna untuk berinteraksi dengan berbagai aspek [MaterialService](/docs/id-id/reference/engine/classes/MaterialService) , termasuk membuat materi khusus baru dan menerapkannya ke bagian dan [tanah](/docs/id-id/parts/terrain).Bahan khusus diwakili oleh [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) instansi dalam [MaterialService](/docs/id-id/reference/engine/classes/MaterialService) .
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Explorer-MaterialVariant-Instances.png' alt='Explorer window showing two MaterialVariant instances within MaterialService' title='' width='320' height='' />Anda dapat menerapkan bahan khusus per bagian atau secara global ke kedua bagian dan medan, dan Anda dapat menyesuaikan bagaimana bahan khusus diterapkan ke wajah medan dengan [TerrainDetail](/docs/id-id/reference/engine/classes/TerrainDetail) instansi.
[MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) dan [SurfaceAppearance](/docs/id-id/reference/engine/classes/SurfaceAppearance) instans keduanya menggunakan [PBR](/docs/id-id/art/modeling/surface-appearance) tekstur untuk menyesuaikan penampilan objek.Perbedaannya adalah bahwa [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) adalah untuk menyesuaikan penampilan bahan yang dapat diulang, sementara [SurfaceAppearance](/docs/id-id/reference/engine/classes/SurfaceAppearance) adalah untuk menyesuaikan penampilan mesh tertentu dengan pemetaan UV.[MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) instans juga memiliki [properti fisik](#physical-properties) yang [SurfaceAppearance](/docs/id-id/reference/engine/classes/SurfaceAppearance) tidak dimiliki instans.
### [Buat materi khusus](#buat-materi-khusus)
Anda dapat mengedit semua properti material khusus di [Manajer Bahan](#material-manager) atau melalui properti instansi [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant).Anda juga dapat menghasilkan materi khusus melalui [Pembangkit Bahan Berbasis Prompt](/docs/id-id/studio/material-generator) .
Untuk membuat materi khusus di [Manajer Bahan](#material-manager):
1. Klik materi dasar dari mana materi khusus Anda akan mewarisi [properti fisik](#physical-properties).Jika Anda melewati langkah ini, material dasar akan menjadi Plastik , tetapi Anda dapat mengubahnya nanti.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Base-Material-Selected.png' alt='A Base material of Asphalt that's selected in the Material Manager.' title='' width='700' height='' />
2. Di sudut kiri atas, klik Buat Variasi Bahan .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Create-Material-Variant.png' alt='Create Material Variant button indicated in Material Manager.' title='' width='700' height='' />Varian baru muncul di palet dengan ikon di sudut kanan bawah, menunjukkan bahwa itu adalah bahan khusus.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Custom-Material-Icon.png' alt='New MaterialVariant tile in Material Manager with icon to indicate a custom material.' title='' width='700' height='' />
3. Di inspektur, ganti nama materi kustom Anda untuk menggambarkan tujuannya.Anda dapat mengubah nama nanti, tetapi jika Anda melakukannya setelah menerapkan materi ke bagian, Anda perlu menerapkannya kembali ke bagian\-bagian itu.
4. Untuk setiap opsi peta tekstur seperti Warna atau Normal , tempelkan ID aset atau impor teksur baru dari komputer Anda.Texture kotak bekerja paling baik.Jika Anda tidak menentukan aset untuk peta tekstur, tekstur tetap kosong.
5. Jika diinginkan, sesuaikan nilai Studs Per Tile dan Pola untuk mengubah tampilan material.
Jika diperlukan, Anda dapat menghapus materi khusus dari [Manajer Bahan](#material-manager) dengan memilihnya dan mengklik tombol Hapus di bawah pratinjau globenya.Alternatifnya, Anda dapat menghapus instansi terkaitnya [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) dalam Layanan Material dari [Explorer](/docs/id-id/studio/explorer).
### [Terapkan bahan khusus](#terapkan-bahan-khusus)
Untuk [bagian](/docs/id-id/parts) , Anda dapat menggunakan bahan khusus seperti bahan lainnya, menerapkannya ke bagian yang dipilih melalui widget [Material](#apply-materials) atau [Manajer Bahan](#material-manager).¹
Anda juga dapat menerapkan materi baru ke bagian dengan mengatur properti Material Variant di jendela [Properti](/docs/id-id/studio/properties).Dalam kasus ini, Studio secara otomatis mengatur properti Materialnya ke material dasar yang Anda pilih saat membuat materi.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Properties-Material-And-MaterialVariant.png' alt='Material and MaterialVariant properties set in the Properties window.' title='' width='320' height='' />Perhatikan bahwa jika Anda mengganti nama materi khusus setelah menerapkannya ke bagian, bagian\-bagian tersebut tidak akan secara otomatis menggunakan materi khusus dengan nama baru.Perilaku ini memungkinkan [Material Adaptif](#adaptive-materials).Jika Anda ingin bagian terus menggunakan bahan khusus setelah Anda menggantinya, Anda perlu menerapkan kembali bahan khusus.
*¹ Tidak seperti pada bagian, Anda tidak dapat langsung menerapkan bahan khusus ke [medan](/docs/id-id/parts/terrain), meskipun Anda dapat mengatur bahan khusus sebagai [penghapus bahan](#material-overrides) ke bahan dasar yang ada untuk semua medan menggunakan bahan itu.*
### [Penghapusan materi](#penghapusan-materi)
Anda dapat mengatur materi khusus sebagai penghapus materi untuk menjadikan materi dasarnya sebagai referensi untuk materi khusus untuk membuat basis materi menjadi referensi untuk materi khusus.Ketika Anda melakukannya, Studio akan menggunakan bahan khusus untuk kedua tekstur dan [properti fisik](#physical-properties) dari bagian mana pun atau [tanah](/docs/id-id/parts/terrain) yang menggunakan bahan khusus.
Penghapusan materi adalah satu\-satunya cara untuk menerapkan materi khusus ke medan.Perhatikan juga bahwa bahan untuk medan adalah global per tempat, jadi Anda tidak dapat menerapkan beberapa variasi dari bahan dasar yang sama ke medan di satu tempat.
#### [Tetapkan pengecualian](#tetapkan-pengecualian)
Untuk mengatur materi khusus sebagai penghapus materi di [Manajer Bahan](#material-manager):
1. Klik materi khusus yang ingin Anda atur sebagai pengecualian.
2. Di inspektur, gulir ke bawah ke Penghapusan dan aktifkan Tetapkan sebagai Penghapusan .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Set-Override-Enabled.png' alt='.' title='' width='320' height='' />Penghapus baru muncul sebagai properti MaterialService di jendela [Properti](/docs/id-id/studio/properties).
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Properties-View-Override.png' alt='' title='' width='320' height='' />
#### [Detail medan](#detail-medan)
Secara default, menerapkan bahan khusus ke bagian atau sebagai penghapus menerapkan bahan khusus itu sebagai ubin di setiap wajah.Untuk medan, Anda dapat secara opsional mengonfigurasi [TerrainDetail](/docs/id-id/reference/engine/classes/TerrainDetail) untuk menyesuaikan bagian atas , sisi , dan bagian bawah medan vokal menggunakan bahan khusus itu.
Untuk menyesuaikan wajah medan menggunakan bahan khusus:
1. Di palet dari [Manajer Bahan](#material-manager), klik bahan khusus.
2. Di inspektur, konfirmasikan bahwa toggle Atur sebagai Pengganti nya diaktifkan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Set-Override-Enabled.png' alt='' title='' width='320' height='' />
3. Di bagian Detail Tanah , klik Buat untuk setiap wajah yang ingin Anda mengustomisasi.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Terrain-Details-Create-Buttons.png' alt='' title='' width='320' height='' />
4. Untuk setiap wajah yang Anda aktifkan, perluas panah untuk mengakses dan mengedit detail seperti namanya, peta tekstur, kancing per ubin, dan pola.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Terrain-Details-Edit.png' alt='' title='' width='320' height='' />
#### [Nonaktifkan pengecualian](#nonaktifkan-pengecualian)
Anda dapat menonaktifkan seluruh penghapusan materi dan semua materi dasar yang saat ini dihapuskan, atau Anda dapat menonaktifkan penghapusan untuk materi dasar tertentu.
Nonaktifkan Penghapusan Seluruh Pengganti
Nonaktifkan Penghapusan untuk Material Tertentu
1. Di palet [Manajer Bahan](#material-manager), klik bahan kustom yang digunakan sebagai penghapus.
2. Di inspektur, gulir ke bawah ke Penghapusan dan nonaktifkan Tetapkan sebagai Penghapusan .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Set-Override-Disabled.png' alt='' title='' width='320' height='' />
## [Properti fisik](#properti-fisik)
Semua bahan memiliki properti fisik bawaan seperti kepadatan, elastisitas, dan gesekan .Melalui penerapan [material khusus](#custom-materials) dengan properti fisik unik, Anda dapat mempengaruhi perilaku materi global untuk semua bagian dan [tanah](/docs/id-id/parts/terrain) yang menggunakan materi khusus, seperti menciptakan varian sangat licin dari materi Es .
Saat mempertimbangkan properti fisik, mesin memprioritaskan pengaturan per bagian yang lebih granuler atas perilaku materi untuk menentukan properti fisik yang efektif dari permukaan:
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Arrow-Highest.png' alt='' title='' width='50' height='' />Properti fisik khusus dari bagian tertentu.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Arrow-Higher.png' alt='' title='' width='50' height='' />Properti fisik khusus dari bahan kustom bagian.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Arrow-High.png' alt='' title='' width='50' height='' />Properti fisik khusus dari [penghapusan materi bagian](#setting-overrides) dari materi bagian.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Arrow-Neutral.png' alt='' title='' width='50' height='' />Properti fisik default [dari materi bagian](#default-physical-properties).
Mengajukan ke Material Kustom
Penghapusan Per\-Bagian
Untuk mengatur properti fisik unik untuk setiap [material khusus](#custom-materials) dan secara otomatis menerapkannya ke semua bagian dan [tanah](/docs/id-id/parts/terrain) yang menggunakan materi:
1. Di palet dari [Manajer Bahan](#material-manager), klik bahan khusus.
2. Di inspektur, gulir ke bawah ke bagian Fisika dan atur properti fisik khusus seperti yang dijelaskan dalam referensi [PhysicalProperties](/docs/id-id/reference/engine/datatypes/PhysicalProperties).
<img src='https://prod.docsiteassets.roblox.com/assets/studio/material-manager/Physical-Properties.png' alt='Custom physical properties in Material Manager inspector pane' title='' width='320' height='' />Untuk setiap bagian yang menggunakan bahan khusus dan melakukan tidak memiliki pengecualian khusus bagian di jendela Properti , cabang CurrentPhysicalProperties di jendela Properti mengungkapkan bahwa properti fisik defaultnya dihapuskan oleh properti bahan khusus.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/materials/Properties-Physical-Overridden.png' alt='Properties window showing physical properties overridden by those of custom material' title='' width='320' height='' />
## [Material adaptif](#material-adaptif)
Ketika Anda menerapkan materi khusus ke bagian, properti bagian [Part.MaterialVariant](/docs/id-id/reference/engine/classes/Part#MaterialVariant) menjadi nama bagiannya [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) bukan instans kejadian.Ini berarti bahwa ketika Anda menggunakan kembali bagian di tempat yang sama atau berbeda, seperti dalam model atau paket, lebih mudah bagi Anda untuk menyesuaikan materi kustom yang berbeda untuk menyesuaikan penampilan bagian.Perilaku adaptif dari materi khusus memiliki efek berikut:
* Jika Anda membuat koleksi materi khusus dengan nama yang sama tetapi tekstur yang berbeda, maka Anda dapat dengan cepat mengubah gaya tempat dengan mengubah koleksi mana yang menjadi anak dari [MaterialService](/docs/id-id/reference/engine/classes/MaterialService) .
* Jika Anda menyisipkan model dengan bagian yang menggunakan bahan khusus, maka Anda dapat mengubah penampilannya dengan membuat instansi [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) di [MaterialService](/docs/id-id/reference/engine/classes/MaterialService) dan menggantinya dengan nama yang sama dengan bahan kustom sebelumnya, bukan dengan menerapkan bahan baru ke bagian dalam model.
Ketika Anda menggunakan kembali materi khusus di model dan paket, setiap instansi MaterialVariant harus berada di [MaterialService](/docs/id-id/reference/engine/classes/MaterialService) agar berfungsi.
* Jika Anda mendistribusikan model ke Toko Pencipta dengan materi khusus, sertakan instansi [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) dalam model.Untuk informasi lebih lanjut tentang mendistribusikan model ke Toko Kreator, lihat [Mendistribusikan Aset](/docs/id-id/production/creator-store).
* Jika Anda menyisipkan model dari Toko Pencipta, cari instance [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) apa pun dan salin ke [MaterialService](/docs/id-id/reference/engine/classes/MaterialService) .Untuk informasi lebih lanjut tentang impor model dari Toko Pencipta, lihat [Toko Pencipta](/docs/id-id/production/creator-store).
* Jika Anda ingin menggunakan bahan khusus dengan paket, letakkan paket di [MaterialService](/docs/id-id/reference/engine/classes/MaterialService) . Untuk informasi lebih lanjut tentang paket, lihat [Paket](/docs/id-id/projects/assets/packages) .
Toko [Pencipta](/docs/id-id/production/creator-store) memiliki kategori yang disebut Material untuk "paket bahan", model yang hanya berisi [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) , [TerrainDetail](/docs/id-id/reference/engine/classes/TerrainDetail) , [Folder](/docs/id-id/reference/engine/classes/Folder) , dan [Model](/docs/id-id/reference/engine/classes/Model) instansi.Kategori Bahan adalah cara untuk mempromosikan dan menemukan bahan khusus oleh pencipta lain.
Untuk memanfaatkan sebaik\-baiknya materi adaptif, gunakan konvensi nama konsisten untuk instansi [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant) Anda.Sebagai contoh, Anda dapat menggunakan PascalCase dengan bahan dasar materi kustom sebagai kata pertama, seperti di GrassWet , GrassDry , dan GrassBurned .
## [Referensi aset dan properti](#referensi-aset-dan-properti)
### [Bahan dasar](#bahan-dasar)
Shader menghasilkan tampilan dan perasaan bahan.Shader bahan dasar bekerja berbeda dari shader yang digunakan [MaterialVariant](/docs/id-id/reference/engine/classes/MaterialVariant), jadi Anda tidak dapat membuat bahan khusus yang terlihat persis seperti bahan dasar, tetapi Anda masih dapat membuat bahan khusus yang menggunakan teksturnya.Tabel berikut daftar ID aset untuk rincian materi seperti [ColorMap](/docs/id-id/reference/engine/classes/SurfaceAppearance#ColorMap) dan [RoughnessMap](/docs/id-id/reference/engine/classes/SurfaceAppearance#RoughnessMap) .
Dasar Saat Ini
Dasar Pra\-2022
Tanah Saat Ini
Tanah Pra\-2022
| Bahasa | Peta Warna | Biasa | Metalitas | Ketidakhalusan |
| --- | --- | --- | --- | --- |
| Aspal | 9930003046 | 9429449876 | | 9429450346 |
| Batu Api | 9920482056 | 9438412214 | | 9438412457 |
| Bata | 9920482813 | 9438453152 | | 9438453413 |
| Karton | 14108651729 | 14108654002 | | 14108654299 |
| Karpet | 14108662587 | 14108663154 | | 14108663726 |
| Ubin Keramik | 17429425079 | 17429425915 | 17429426100 | 17429426861 |
| Ubin Atap Tanah Liat | 18147681935 | 18147683410 | | 18147684855 |
| Batu Kali | 9919718991 | 9438457162 | | 9438457470 |
| Beton | 9920484153 | 9466554006 | | 9466554186 |
| Logam Berkarat | 9920589327 | 9439548484 | 9439548749 | 9439556441 |
| Lava Retak | 9920484943 | 9438508790 | | 9438509046 |
| Pelat Berlian | 10237720195 | 9438583222 | 9438583347 | 9438583558 |
| Kain | 9920517696 | 9873280412 | | 9873282563 |
| Kertas Timah | 9466552117 | 9424786192 | 9424786272 | 9424786620 |
| Medan Kekuatan \* | | | | |
| Gletser | 9920518732 | 9438812958 | | 9438851286 |
| Kaca | 9438868521 | 7547304785 | | 7547304892 |
| Granit | 9920550238 | 9438882935 | | 9438883109 |
| Rumput | 9920551868 | 9438955773 | | 9438955997 |
| Tanah | 9920554482 | 9439043558 | | 9439043765 |
| Es | 9920555943 | 9467301039 | | 9467301203 |
| Rumput Berdaun | 9920557906 | 9439080781 | | 9439080950 |
| Kulit | 14108670073 | 14108670486 | | 14108670748 |
| Batu Kapur | 9920561437 | 9439415191 | | 9439415495 |
| Marmer | 9439430596 | 9439431240 | | 9439431383 |
| Logam | 9920574687 | 9873295432 | 9873318201 | 9873318890 |
| Lumpur | 9920578473 | 9439509827 | | 9439510012 |
| Neon \* | | | | |
| Jalanan | 9920579943 | 9439519281 | | 9439519532 |
| Batu Besar | 9920581082 | 9439528644 | | 9439537267 |
| Plaster | 14108671255 | 14108671870 | | 14108672378 |
| Plastik \* | | | | |
| Batu | 9920587470 | 9439538417 | | 9439545859 |
| Genteng Atap | 119722544879522 | 77534750680073 | | 129397260312247 |
| Karet | 14108673018 | 14108674698 | 14108674894 | 14108675142 |
| Garam | 9920590225 | 9439565809 | | 9439566688 |
| Pasir | 9920591683 | 9439577084 | | 9439577327 |
| Batu Pasir | 9920596120 | 9439596530 | | 9439596711 |
| Slate | 9920599782 | 9439612514 | | 9439612733 |
| Plastik Mulus \* | | | | |
| Salju | 9920620284 | 9439632006 | | 9439632145 |
| Kayu | 9920625290 | 9439641376 | | 9439648605 |
| Balok Kayu | 9920626778 | 9439650689 | | 9439658127 |
*\* Bahan unik dan/atau aset teksturnya dibundel dengan Studio alih\-alih dapat diakses sebagai ID aset tipikal.*
Bahan dasar ditingkatkan pada 2022 untuk mendukung bahan khusus.Tempat baru menggunakan bahan yang ditingkatkan secara default, tetapi Anda mungkin perlu secara eksplisit mengaktifkan bahan yang ditingkatkan untuk tempat\-tempat lama dengan memilih Layanan Material di jendela [Explorer](/docs/id-id/studio/explorer) dan kemudian, di jendela [Properti](/docs/id-id/studio/properties), mengaktifkan properti Gunakan2022Materials nya.Perhatikan bahwa setelah meningkatkan, Anda mungkin perlu menyesuaikan warna medan karena medan yang dibuat dengan bahan yang ditingkatkan menggunakan tinta bukan pergeseran warna.
### [Warna dasar](#warna-dasar)
Tabel berikut daftar nilai RGB default untuk setiap bahan dasar.Untuk informasi tentang cara mengecat bagian dan medan, lihat [Bagian](/docs/id-id/parts#color-parts) dan [Medan Lingkungan](/docs/id-id/parts/terrain#custom-terrain-colors).
| Bahasa | Nilai RGB | Warna |
| --- | --- | --- |
| Aspal | \[80, 84, 84] | |
| Batu Api | \[75, 74, 74] | |
| Bata | \[138, 97, 73] | |
| Karton | \[255, 206, 152] | |
| Permadani | \[163, 162, 165] | |
| Ubin Keramik | \[181, 173, 156] | |
| Ubin Atap Tanah Liat | \[255, 142, 87] | |
| Batu Kali | \[134, 134, 118] | |
| Beton | \[152, 152, 152] | |
| Logam Berkarat | \[104, 140, 173] | |
| Lava Retak | \[255, 24, 67] | |
| Pelat Berlian | \[168, 175, 176] | |
| Kain | \[194, 193, 168] | |
| Kertas timah | \[168, 175, 176] | |
| Medan Gaya | \[163, 162, 165] | |
| Gletser | \[221, 228, 229] | |
| Kaca | \[138, 167, 168] | |
| Granit | \[149, 146, 139] | |
| Rumput | \[111, 126, 62] | |
| Tanah | \[140, 130, 104] | |
| Es | \[204, 210, 223] | |
| Rumput Berdaun | \[106, 134, 64] | |
| Kulit | \[110, 73, 53] | |
| Batu Kapur | \[255, 243, 192] | |
| Marmer | \[122, 122, 122] | |
| Logam | \[168, 175, 176] | |
| Lumpur | \[121, 112, 98] | |
| Neon | \[163, 162, 165] | |
| Perkerasan | \[143, 144, 135] | |
| Batu Besar | \[122, 122, 118] | |
| Plaster | \[204, 142, 105] | |
| Plastik | \[163, 162, 165] | |
| Batu | \[99, 100, 102] | |
| Genteng Atap | \[66, 66, 66] | |
| Karet | \[32, 32, 32] | |
| Garam | \[255, 255, 254] | |
| Pasir | \[207, 203, 167] | |
| Batu Pasir | \[148, 124, 95] | |
| Batu Tulis | \[88, 89, 86] | |
| Plastik Mulus | \[163, 162, 165] | |
| Salju | \[235, 253, 255] | |
| Kayu | \[172, 148, 108] | |
| Balok Kayu | \[172, 148, 108] | |
### [Properti fisik default](#properti-fisik-default)
Tabel berikut daftar properti fisik default dari setiap bahan seperti yang dijelaskan dalam referensi [PhysicalProperties](/docs/id-id/reference/engine/datatypes/PhysicalProperties).Untuk informasi tentang menyesuaikan properti fisik, lihat [Properti fisik](#physical-properties).
| Bahasa | Kekuatan密度 | Elastisitas | Berat Kekuatan Elastis | Kerusakan | Berat gesekan |
| --- | --- | --- | --- | --- | --- |
| Aspal | 2\.36 | 0\.2 | 1 | 0\.8 | 0\.3 |
| Batu Api | 2\.691 | 0\.15 | 1 | 0\.7 | 0\.3 |
| Batu bata | 1\.922 | 0\.15 | 1 | 0\.8 | 0\.3 |
| Kardus | 0\.7 | 0\.05 | 2 | 0\.5 | 1 |
| Permadani | 1\.1 | 0\.25 | 2 | 0\.4 | 1 |
| Ubin Keramik | 2\.4 | 0\.2 | 1 | 0\.51 | 1 |
| Ubin Atap Tanah Liat | 2 | 0\.2 | 1 | 0\.51 | 1 |
| Batu Kerikil | 2\.691 | 0\.17 | 1 | 0\.5 | 1 |
| Beton | 2\.403 | 0\.2 | 1 | 0\.7 | 0\.3 |
| Logam Berkarat | 7\.85 | 0\.2 | 1 | 0\.7 | 1 |
| Lava Retak | 2\.691 | 0\.15 | 1 | 0\.65 | 1 |
| Pelat Berlian | 7\.85 | 0\.25 | 1 | 0\.35 | 1 |
| Kain | 0\.7 | 0\.05 | 1 | 0\.35 | 1 |
| Kertas Timah | 2\.7 | 0\.25 | 1 | 0\.4 | 1 |
| Medan Gaya | 2\.403 | 0\.2 | 1 | 0\.25 | 1 |
| Gunung Berapi | 0\.919 | 0\.15 | 1 | 0\.05 | 2 |
| Kaca | 2\.403 | 0\.2 | 1 | 0\.25 | 1 |
| Granit | 2\.691 | 0\.2 | 1 | 0\.4 | 1 |
| Hijau | 0\.9 | 0\.1 | 1\.5 | 0\.4 | 1 |
| Tanah | 0\.9 | 0\.1 | 1 | 0\.45 | 1 |
| Es | 0\.919 | 0\.15 | 1 | 0\.02 | 3 |
| Tanaman Berdaun | 0\.9 | 0\.1 | 2 | 0\.4 | 2 |
| Sulit | 0\.86 | 0\.25 | 1 | 0\.35 | 1 |
| Batu Kapur | 2\.691 | 0\.15 | 1 | 0\.5 | 1 |
| Marmer | 2\.563 | 0\.17 | 1 | 0\.2 | 1 |
| Logam | 7\.85 | 0\.25 | 1 | 0\.4 | 1 |
| Lumpur | 0\.9 | 0\.07 | 4 | 0\.3 | 3 |
| Neon | 0\.7 | 0\.2 | 1 | 0\.3 | 1 |
| Paviliun | 2\.691 | 0\.17 | 1 | 0\.5 | 0\.3 |
| Pecahan | 2\.403 | 0\.17 | 1\.5 | 0\.4 | 1 |
| Plaster | 0\.75 | 0\.2 | 1 | 0\.6 | 0\.3 |
| Plastik | 0\.7 | 0\.5 | 1 | 0\.3 | 1 |
| Batu | 2\.691 | 0\.17 | 1 | 0\.5 | 1 |
| Papan Atap | 2\.36 | 0\.2 | 1 | 0\.8 | 0\.3 |
| Karet | 1\.3 | 0\.95 | 2 | 1\.5 | 3 |
| Laut | 2\.165 | 0\.05 | 1 | 0\.5 | 1 |
| Pasir | 1\.602 | 0\.05 | 2\.5 | 0\.5 | 5 |
| Batu Pasir | 2\.691 | 0\.15 | 1 | 0\.5 | 5 |
| Plastik Mulus | 0\.7 | 0\.5 | 1 | 0\.2 | 1 |
| Lembaran | 2\.691 | 0\.2 | 1 | 0\.4 | 1 |
| Salju | 0\.9 | 0\.03 | 4 | 0\.3 | 3 |
| Kayu | 0\.35 | 0\.2 | 1 | 0\.48 | 1 |
| Papan Kayu | 0\.35 | 0\.2 | 1 | 0\.48 | 1 |
| 93 |
https://create.roblox.com/docs/id-id/parts/terrain
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
Bahasa Indonesia
Masukan
# Tanah lingkungan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/parts/terrain).
Editor Tanah Studio memungkinkan Anda menghasilkan dan memahat lingkungan medan terperinci dan realistis seperti gunung, badai air, bukit yang ditumbuhi rumput, atau padang pasir datar.Tanah terdiri dari grid dari voksels yang merupakan wilayah 4×4×4 stud di dunia 3D dengan bahan tertentu.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Showcase.jpg' alt='Desert terrain with mountains in the distance' title='' width='100%' height='' />Menggunakan Editor Tanah, Anda dapat dengan mudah [menghasilkan](#generate-terrain) dan mengedit tanah entah di tingkat [voxel](#detailed-editing) atau [wilayah](#large-scale-editing) dengan opsi untuk mengekspor [peta ketinggian](#heightmaps-and-colormaps) dan [peta warna](#heightmaps-and-colormaps).Untuk pengeditan wilayah yang lebih tepat, dinamis, atau prosedural, Anda juga dapat [skrip](#scripting) kreasiwilayah.
## [Bahan medan](#bahan-medan)
Bahan default berikut tersedia untuk medan, dan Anda juga dapat menerapkan [material khusus](/docs/id-id/parts/materials#custom-materials).Bahan mempengaruhi bentuk dan penampilan medan di dunia; misalnya, [rumput beranimasi](#grass-animation) hanya menampilkan pada bahan Rumput dan Air materi [gelombang dan kilauan](#water-appearance) dengan gerakan halus.
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Asphalt.jpg' alt='Appearance of Asphalt material' title='' width='100%' height='' />
*Aspal*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Basalt.jpg' alt='Appearance of Basalt material' title='' width='100%' height='' />
*Batu Api*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Brick.jpg' alt='Appearance of Brick material' title='' width='100%' height='' />
*Bata*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Cobblestone.jpg' alt='Appearance of Cobblestone material' title='' width='100%' height='' />
*Batu Kerikil*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Concrete.jpg' alt='Appearance of Concrete material' title='' width='100%' height='' />
*Beton*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Cracked-Lava.jpg' alt='Appearance of Cracked Lava material' title='' width='100%' height='' />
*Lava Retak*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Glacier.jpg' alt='Appearance of Glacier material' title='' width='100%' height='' />
*Gunung Berapi*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Grass.jpg' alt='Appearance of Grass material' title='' width='100%' height='' />
*Rumput*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Ground.jpg' alt='Appearance of Ground material' title='' width='100%' height='' />
*Tanah*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Ice.jpg' alt='Appearance of Ice material' title='' width='100%' height='' />
*Es*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Leafy-Grass.jpg' alt='Appearance of Leafy Grass material' title='' width='100%' height='' />
*Rumput Berdaun*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Limestone.jpg' alt='Appearance of Limestone material' title='' width='100%' height='' />
*Batu Kapur*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Mud.jpg' alt='Appearance of Mud material' title='' width='100%' height='' />
*Lumpur*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Pavement.jpg' alt='Appearance of Pavement material' title='' width='100%' height='' />
*Perkerasan*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Rock.jpg' alt='Appearance of Rock material' title='' width='100%' height='' />
*Batu*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Salt.jpg' alt='Appearance of Salt material' title='' width='100%' height='' />
*Garam*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Sand.jpg' alt='Appearance of Sand material' title='' width='100%' height='' />
*Pasir*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Sandstone.jpg' alt='Appearance of Sandstone material' title='' width='100%' height='' />
*Batu Pasir*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Slate.jpg' alt='Appearance of Slate material' title='' width='100%' height='' />
*Pelat*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Snow.jpg' alt='Appearance of Snow material' title='' width='100%' height='' />
*Salju*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Water.jpg' alt='Appearance of Water material' title='' width='100%' height='' />
*Air*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Wood-Planks.jpg' alt='Appearance of Wood Planks material' title='' width='100%' height='' />
*Balok Kayu*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Material-Air.png' alt='Air material icon (no visual appearance)' title='' width='100%' height='' />
*Udara*
### [Penampilan air](#penampilan-air)
Secara default, air permukaan bergelombang, bergoyang, dan berkilau dengan gerakan halus.
[https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Water-Appearance.mp4](https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Water-Appearance.mp4)
Untuk menyesuaikan warna dan gerakan air:
1. Di jendela Explorer , navigasikan ke Ruang kerja , lalu pilih objek Tanah .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Workspace-Terrain.png' alt='Terrain object shown in Explorer window of Studio' title='' width='320' height='' />
2. Di jendela Properti , sesuaikan penampilan air melalui properti berikut:
| Propinsi | Deskripsi |
| --- | --- |
| Warna Air | Menyesuaikan warna keseluruhan semua air tanah di pengalaman. |
| Pencerminan Air | Menyesuaikan berapa banyak permukaan air mencerminkan langit dan objek di sekitarnya dari nilai 1 (tinggi) hingga 0 (tidak ada). |
| Transparansi Air | Menyesuaikan seberapa transparan air dari nilai 1 (hapus) menjadi 0 (tidak transparan). |
| Ukuran Gelombang Air | Sesuaikan ukuran gelombang dari nilai 1 (besar) menjadi 0 (tidak ada). |
| Kecepatan Gelombang Air | Menyesuaikan kecepatan gelombang dari nilai 100 (turbulent) menjadi 0 (masih). |
Jika Anda memiliki tempat dengan medan pantai (tempat pertemuan air), disarankan untuk meningkatkan garis pantai Anda untuk meningkatkan cara air bergabung dengan tanah.Semua templat Studio sudah menggunakan teknologi yang ditingkatkan, dan Anda dapat memeriksa tempat yang disimpan sebelumnya dengan membuka [Editor Tanah](/docs/id-id/studio/terrain-editor) dan mencari prompt Peningkatan .
Beberapa properti air hanya terlihat saat pengujian permainan.Untuk melihat semua properti saat diedit, buka Pengaturan Studio , cari Tingkat Kualitas Editor , dan atur ke leveltertinggi.
### [animasirumput](#animasirumput)
Sementara sebagian besar bahan statis, Anda dapat menambahkan pisau bergerak rumput ke material medan Tanah .Secara default, rumput mengayun dengan lembut dalam angin simulasi, dan Anda dapat menyesuaikan arah/kekuatan animasinya melalui [angin global](/docs/id-id/environment/global-wind).
[https://prod.docsiteassets.roblox.com/assets/lighting-and-effects/aero-fluid-dynamics/Global-Wind-Showcase.mp4](https://prod.docsiteassets.roblox.com/assets/lighting-and-effects/aero-fluid-dynamics/Global-Wind-Showcase.mp4)
Untuk menambahkan rumput beranimasi ke material Gras :
1. Di jendela Explorer , navigasikan ke Ruang kerja , lalu pilih objek Tanah .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Workspace-Terrain.png' alt='Terrain object shown in Explorer window of Studio' title='' width='320' height='' />
2. Di jendela Properti , beralih pada properti Dekorasi .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Terrain-Decoration.png' alt='Decoration property of Terrain object in Properties window of Studio' title='' width='320' height='' />
3. Sesuaikan panjang rumput dengan memasukkan nilai di antara 0\.1 dan 1 untuk properti Panjang Rumput .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Terrain-GrassLength.png' alt='GrassLength property of Terrain object in Properties window of Studio' title='' width='320' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Terrain-GrassLength.jpg' alt='GrassLength comparison depicted on rolling grassland hills.' title='' width='720' height='' />
4. Sesuaikan arah dan kekuatan animasinya melalui [angin global](/docs/id-id/environment/global-wind).
### [Warna medan khusus](#warna-medan-khusus)
Setiap material medan diberi warna default, tetapi Anda dapat menyesuaikan warna materi apa pun untuk lebih sesuai dengan pengalaman Anda.
Standar
Fantasi
Tundra
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Showcase.jpg' alt='Default terrain colors used in desert landscape' title='' width='800' height='450' />Untuk menyesuaikan warna material lain selain air:
1. Di jendela Explorer , navigasikan ke Ruang kerja , lalu pilih objek Tanah .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/explorer/Workspace-Terrain.png' alt='Terrain object shown in Explorer window of Studio' title='' width='320' height='' />
2. Di jendela Properti , perluas Warna Material . Semua materi ditampilkan dengan kode RGB mereka.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/properties/Terrain-MaterialColors-Expand.png' alt='MaterialColors property shown in Properties window of Studio' title='' width='320' height='' />
3. Untuk setiap materi, baik memasukkan kode RGB baru atau klik kotak warna untuk membuka [popup warna](/docs/id-id/parts#colors-popup).
## [Hasilkan medan](#hasilkan-medan)
Menggunakan alat dan metode berikut, Anda dapat menghasilkan area tanah besar secara prosedural dengan alat Hasilkan atau skrip, atau secara otomatis berdasarkan peta ketinggian dan peta warna.
### [Hasilkan alat](#hasilkan-alat)
Alat Hasilkan memungkinkan Anda untuk menghasilkan tanah secara prosedural dalam beberapa detik.Ini berguna jika Anda ingin membuat peta besar dan menyempurnakan [detail medan](#detailed-editing).
1. Di Editor Tanah , navigasikan ke tab Buat dan pilih alat Hasilkan .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Create-Tab-Generate.png' alt='Generate tool indicated in Create tab of Terrain Editor' title='' width='360' height='' />
2. Di jendela pandang 3D, gerakkan/ubah ukuran wilayah pemilihan di mana untuk menghasilkan medan.Alternatifnya, perluas Pengaturan Pilihan Alat dan masukkan nilai ke dalam input X / Y / Z untuk menetapkan ukuran dan posisi tertentu.
3. Di bagian Pengaturan Bioma dari alat, pilih bioma berikut untuk dimasukkan ke dalam medan baru:
* Arktik
* Dunes
* Ngarai
* Lavascape
* Air
* Gunung
* Bukit
* Dataran
* Rawa
4. Klik tombol Menghasilkan .
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Generate-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Generate-Tool.mp4)
### [Peta ketinggian dan peta warna](#peta-ketinggian-dan-peta-warna)
A peta ketinggian adalah representasi 2D dari peta medan 3D, seperti yang dilihat langsung dari atas.Area yang lebih terang dari hasil peta ketinggian menghasilkan medan yang lebih tinggi, seperti gunung, sementara area yang lebih gelap menghasilkan wilayah yang lebih rendah, seperti lembah.
Peta warna opsional , bersama dengan peta ketinggian, mengubah warna menjadi bahan medan menggunakan kunci warna .
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Terrain-Heightmap.png' alt='Example heightmap image' title='' width='100%' height='' />
*Peta Ketinggian*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Terrain-Colormap.png' alt='Example colormap image' title='' width='100%' height='' />
*Peta Warna*
<img src='https://prod.docsiteassets.roblox.com/assets/modeling/terrain/Terrain-Colormap-Result.jpg' alt='Terrain generated from the example heightmap and colormap' title='' width='100%' height='' />
*Tanah yang dihasilkan*
1 piksel dalam peta ketinggian mewakili 4 kancing di Studio, dan Studio mendukung maksimal 4096×4096 piksel dalam format .jpg atau .png .
Untuk men导入 peta ketinggian dan peta warna opsional:
1. Di Editor Tanah , navigasikan ke tab Buat dan pilih alat Impor .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Create-Tab-Import.png' alt='Import tool indicated in Create tab of Terrain Editor' title='' width='360' height='' />
2. Di bagian Pengaturan Peta alat, klik tombol impor dan pilih gambar yang ingin Anda impor sebagai peta ketinggian.
3. Di bagian Pengaturan Bahan alat, pilih material medan atau, alternatifnya, unggah peta warna.
Bahasa
Peta Warna
Untuk menerapkan satu materi konsisten di seluruh wilayah yang dihasilkan, pilih tab Material dan pilih materi wilayah.
4. Di jendela pandang 3D, gerakkan/ubah ukuran wilayah pemilihan di mana untuk menghasilkan medan.Alternatifnya, masukkan nilai ke bidang alat Pilih untuk menetapkan posisi dan ukuran yang lebih spesifik.
Ketinggian minimum dan maksimum tergantung pada area paling gelap dan paling ringan dari gambar peta ketinggian dalam kaitannya dengan Y ukuran (tinggi) dari wilayah seleksi.Sebagai kejadian, jika Anda memilih ketinggian 128, area hitam murni berada 64 kancing di bawah posisi pusat dan area putih murni berada 64 kancing di atas posisi pusat.
5. Klik tombol Menghasilkan .
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Import-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Import-Tool.mp4)
### [Pemograman](#pemograman)
Anda dapat menulis pembuatan medan menggunakan kelas [Terrain](/docs/id-id/reference/engine/classes/Terrain).Sebagai contoh, untuk membuat medan dengan material rumput yang mengisi volume, Anda dapat menggunakan metode seperti [FillBall()](/docs/id-id/reference/engine/classes/Terrain#FillBall) , [FillBlock()](/docs/id-id/reference/engine/classes/Terrain#FillBlock) , [FillCylinder()](/docs/id-id/reference/engine/classes/Terrain#FillCylinder) , [FillRegion()](/docs/id-id/reference/engine/classes/Terrain#FillRegion) , atau [FillWedge()](/docs/id-id/reference/engine/classes/Terrain#FillWedge) .
```
Isi Volume Blok
---
```
workspace.Terrain:FillBlock(CFrame.new(0, 0, 0), Vector3.new(4, 4, 4), Enum.Material.Grass)
```
```
## [Editasi skala besar](#editasi-skala-besar)
Tab Edit dari Editor Tanah berisi alat untuk editing skala besar.
### [Pilih wilayah](#pilih-wilayah)
Alat Pilih adalah alat universal untuk memilih wilayah berbentuk persegi di medan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Select.png' alt='Select tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />Pilih wilayah dengan mengklik dan seret di jendela 3D, reposisikan dengan penyeret pindahkan , dan ubah ukurannya dengan penangan skala .Alternatifnya, masukkan nilai ke dalam input X / Y / Z dari alat untuk mengatur posisi dan ukuran tertentu.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Select-Region-Labeled.jpg' alt='Move draggers and scale handles on a selected region' title='' width='800' height='' />
*Gerakkan penyeret dan tangan skala pada wilayah yang dipilih*
Studio juga mendukung shortcut keyboard dan mouse berikut, asalkan alat Pilih aktif dan tidak ada yang dipilih di jendela Explorer.
| Jendela | Makan Mac | Tindakan |
| --- | --- | --- |
| CtrlC | ⌘C | Salin medan dalam wilayah yang dipilih ke clipboard. |
| CtrlV | ⌘V | Lemparkan tanah yang telah disalin ke clipboard dan bertukar ke alat Transform sehingga tanah baru dapat diubah. |
| CtrlX | ⌘X | Potong tanah di dalam wilayah yang dipilih ke clipboard. |
| CtrlD | ⌘D | Duplikasi tanah di dalam wilayah yang dipilih dan bertukar ke alat Transform sehingga tanah baru dapat diubah. |
| Delete | Delete | Hapus medan di dalam wilayah yang dipilih. |
| Shift | Shift | Saat dipegang saat menyeret skala apa pun , skala wilayah secara proporsional di semua sumbu lainnya. |
| Ctrl | ⌘ | Saat dipegang saat menyeret skala apa pun , skala wilayah sama di kedua arah positif dan negatif di sepanjang sumbu itu. |
### [Transformasi wilayah](#transformasi-wilayah)
Alat Transformasi memungkinkan Anda untuk memanipulasi seluruh wilayah yang dipilih ke posisi, ukuran, atau orientasi baru.
Untuk mengubah wilayah:
1. Pilih wilayah dan kemudian aktifkan alat Transformasi . Perhatikan bahwa alat akan diaktifkan secara otomatis jika Anda menyalin atau menyalin medan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Transform.png' alt='Transform tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />
2. Di jendela pandang 3D, ubah wilayah dengan penggerak geser , cincin putar , dan tangan skala .Alternatifnya, masukkan nilai ke dalam input X / Y / Z dari alat untuk menetapkan posisi, ukuran, dan rotasi tertentu.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Transform-Region-Labeled.jpg' alt='Move draggers, scale handles, and rotate rings on the Y axis of a selected region' title='' width='780' height='' />Memegang Shift saat menyeret skala apa pun memperluas wilayah secara proporsional di semua sumbu lain, dan memegang Ctrl atau ⌘ saat menyeret skala memperluas wilayah sama di kedua arah positif dan negatif di sepanjang sumbu itu.
Memegang Shift saat menyeret apa pun putar tombol di antara geseran rotasi atau rotasi bebas bentuk.
Secara default, alat ini menggunakan mode Edit Langsung untuk terus memperbarui medan saat Anda mengubahnya.Untuk melihat hanya pratinjau wireframe dari medan saat Anda mengubahnya, nonaktifkan mode edit langsung dan kemudian, saat mengubah, tekan Enter / Return atau klik tombol Terapkan untuk menerapkan perubahan.
### [Isi dan ganti wilayah](#isi-dan-ganti-wilayah)
Alat Isi memungkinkan Anda untuk mengisi seluruh wilayah yang dipilih dengan bahan tertentu, atau menggantikan semua bahan dalam wilayah dengan bahan lain.
Untuk mengisi atau mengganti medan:
1. Pilih wilayah, lalu aktifkan alat Isi .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Fill.png' alt='Fill tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />
2. Di bagian Pengaturan Bahan dari alat:
* Untuk mengisi wilayah dengan material tertentu, pilih Isi dan pilih material yang diinginkan.
* Untuk mengganti seluruh medan satu materi dengan materi lain, pilih Ganti , lalu pilih materi sumber dan target materi.
3. Klik tombol Terapkan atau tekan Enter / Return .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Fill-Region.jpg' alt='Region filled with Salt material' title='' width='780' height='' />
*Wilayah yang dipilih dipenuhi dengan materi Garam*
### [Tetapkan tingkat level](#tetapkan-tingkat-level)
Alat Tingkat Laut memungkinkan Anda untuk membuat tingkat air yang konsisten atau menghapus semua air di dalam wilayah.
Untuk mengatur tingkat level:
1. Aktifkan alat Tingkat Laut .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Sea-Level.png' alt='Sea Level tool indicated in Edit tab of Terrain Editor' title='' width='360' height='' />
2. Pilih wilayah yang dituju dengan mengklik dan menyeret penyeret pindahkan dan penangan skala di jendela 3D.Alternatifnya, masukkan nilai ke dalam input X / Y / Z dari alat untuk mengatur posisi dan ukuran tertentu.
3. Klik tombol Menguap untuk menghapus air di dalam wilayah yang dipilih, atau klik tombol Buat untuk mengisi wilayah yang dipilih dengan air.
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Sea-Level-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Sea-Level-Tool.mp4)
## [Editasi terperinci](#editasi-terperinci)
Tab Edit dari Editor Tanah juga berisi alat untuk editing presisi menggunakan alat "sikat" untuk menggambar, memahat, memperbaiki, atau melukis medan.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Edit-Tab-Detail-Tools.png' alt='Detailed editing tools indicated in Edit tab of Terrain Editor' title='' width='360' height='' />Setiap alat memungkinkan Anda memilih dari bola , kotak , atau silinder bentuk sikat dan ukuran dasar antara 1–64 stud.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Brush-Shape-Size.png' alt='Brush shape and size controls in the Terrain Editor' title='' width='360' height='' />Untuk alat yang menggunakan sikat, Studio mendukung pintasan keyboard dan mouse berikut.
| Jendela | Makan Mac | Tindakan |
| --- | --- | --- |
| Ctrl | ⌘ | Saat dipegang saat menggunakan alat [Menggambar](/docs/id-id/studio/terrain-editor#draw) dan [Memahat](/docs/id-id/studio/terrain-editor#sculpt) , beralih ke mode sikat cadangan.Sebagai contoh, beralih ke mode "pengurangan" alih\-alih mode "tambahan" default. |
| Shift | Shift | Saat dipegang saat menggunakan alat [Menggambar](/docs/id-id/studio/terrain-editor#draw) dan [Memahat](/docs/id-id/studio/terrain-editor#sculpt) , alat [Muluskan](/docs/id-id/studio/terrain-editor#smooth) akan diaktifkan sementara. |
| B | B | Saat dipegang saat menyeret mouse atau menggunakan roda gulir, menyesuaikan ukuran dasar sikat . |
| CtrlB | ⌘B | Saat dipegang saat menyeret mouse atau menggunakan roda gulir, menyesuaikan ketinggian sikat tinggi .Hanya berlaku jika bentuk sikat diatur ke kotak atau silinder . |
| ShiftB | ShiftB | Saat dipegang saat menyeret mouse atau menggunakan roda gulir, menyesuaikan kekuatan sikat kekuatan .Hanya berlaku saat menggunakan alat [Memahat](/docs/id-id/studio/terrain-editor#sculpt), [Melembutkan](/docs/id-id/studio/terrain-editor#smooth), atau [Menyempurnakan](/docs/id-id/studio/terrain-editor#flatten) tool. |
| Alt | ⌥ | Ketika ditekan saat mengklik mouse, menunjukkan pemilih materi. |
### [Menggambar](#menggambar)
Alat Menggambar menambahkan atau mengurangi medan menggunakan sikat.Alat ini berfungsi dalam mode ganda di mana menahan Ctrl atau ⌘ beralih ke mode "pengurangan" bukan mode "tambahan" default.Selain itu, menahan Shift sementara mengaktifkan alat [Mulus](/docs/id-id/studio/terrain-editor#smooth).
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Draw-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Draw-Tool.mp4)
### [Memahat](#memahat)
Alat Memahat menambahkan atau mengurangi medan menggunakan sikat.Tidak seperti alat Draw, alat ini memiliki slider kekuatan untuk memungkinkan manipulasi wilayah yang lebih lembut.
Mirip dengan alat Draw, alat Sculpt berfungsi dalam mode ganda di mana menahan Ctrl atau ⌘ menyalakan mode "subtraksi" alih\-alih mode "tambah" default.Selain itu, menahan Shift sementara mengaktifkan alat Lisir.
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Sculpt-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Sculpt-Tool.mp4)
### [Halus](#halus)
Alat Mulus membuat perbatasan tiba\-tiba menjadi halus di medan menggunakan sikat.Alat ini dapat digunakan dalam mode berdiri sendiri, atau Anda dapat mengaktifkannya dengan menahan Shift saat menggunakan alat Draw atau Sculpt.
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Smooth-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Smooth-Tool.mp4)
### [Memperbaiki](#memperbaiki)
Alat Memperbaiki memperbaiki medan ke tingkat konsisten di sepanjang pesawat yang diceritakan secara visual.Secara default, alat menurunkan medan di atas pesawat dan meningkatkan medan di bawah ke pesawat, tetapi Anda dapat memilih untuk menurunkan secara selektif atau angkat melalui opsi Flatten Mode alat.
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Flatten-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Flatten-Tool.mp4)
### [Lukis](#lukis)
Alat Lukis menggunakan sikat, melukis bahan medan di atas bahan yang ada atau menggantikan satu bahan dengan bahan lain.
[https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Paint-Tool.mp4](https://prod.docsiteassets.roblox.com/assets/studio/terrain-editor/Paint-Tool.mp4)
| 94 |
https://create.roblox.com/docs/id-id/physics
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
6. /
7. [Fisika](/docs/id-id/physics)
Bahasa Indonesia
Masukan
# Fisika
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/physics).
Roblox menggunakan mesin fisika tubuh kaku.Bagian terikat pada kekuatan fisik selama mereka tidak [anchored](/docs/id-id/reference/engine/classes/BasePart#Anchored) .Anda dapat membuat kumpulan fisik [menggunakan lampiran dan keterbatasan](#assemblies), dan Anda dapat mendeteksi dan mengontrol [tabrakan](#collisions) antara objek menggunakan acara dan penyaringan tabrakan.
## [Kumpulan](#kumpulan)
Sebuah [kumpulan](/docs/id-id/physics/assemblies) adalah satu atau lebih [BaseParts](/docs/id-id/reference/engine/classes/BasePart) terhubung oleh batasan kaku atau motor (persambungan kaku bergerak).Kumpulan dapat ditetapkan ke kecepatan linear atau sudut awal, atau perilaku mereka dapat dipengaruhi melalui [batasan](#constraints) .
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Block.png' alt='A light blue cube against a dark blue background that represents an assembly of 1 part.' title='' width='100%' height='' />
*1 pengumpulan; 1 bagian*
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Avatar.png' alt='A humanoid character model against a dark blue background that represents an assembly of 18 parts.' title='' width='100%' height='' />
*1 assemblasi; 18 bagian*
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Ship.png' alt='A pirate that represents an assemble of 179 parts.' title='' width='100%' height='' />
*1 pengumpulan; 179 bagian*
## [Kontraksi](#kontraksi)
Kumpulan yang tidak diikat tidak bereaksi terhadap gaya dari gravitasi dan tabrakan, tetapi gaya fisik juga dapat diterapkan melalui batasan mekanis atau batasan penggerak .
### [Kontraksi mekanik](#kontraksi-mekanik)
Kontraksi mekanis termasuk objek yang sudah dikenal seperti engsel, resor, dan tali yang dapat digunakan untuk membangun mekanisme.Masing\-masing dicakup dalam [batasan mekanis](/docs/id-id/physics/mechanical-constraints) .
[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Spring-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Spring-Demo.mp4)
### [Kontraksi penggerak](#kontraksi-penggerak)
Kontraksi penggerak menerapkan kekuatan atau torsi untuk memindahkan satu atau lebih kumpulan. Setiap diuraikan dalam [kontraksi penggerak](/docs/id-id/physics/mover-constraints) .
[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Torque-RelativeTo-Attachment0.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Torque-RelativeTo-Attachment0.mp4)
## [Tabrakan](#tabrakan)
Peristiwa kolisi secara otomatis terjadi ketika dua [BaseParts](/docs/id-id/reference/engine/classes/BasePart) sentuhan atau berhenti menyentuh di dunia 3D.Anda dapat [mendeteksi](/docs/id-id/workspace/collisions) kolisi ini melalui peristiwa [Touched](/docs/id-id/reference/engine/classes/BasePart#Touched) dan [TouchEnded](/docs/id-id/reference/engine/classes/BasePart#TouchEnded) yang terjadi terlepas dari nilai properti bagian mana pun [CanCollide](/docs/id-id/reference/engine/classes/BasePart#CanCollide).
Melalui [filter kolisi](/docs/id-id/workspace/collisions#collision-filtering) teknik seperti kelompok kolisi atau filterisasi bagian ke bagian, Anda dapat mengontrol kumpulan fisik mana yang bertabrakan dengan orang lain.
Lihat [Tabrakan](/docs/id-id/workspace/collisions) untuk lebih banyak rincian tentang deteksi dan penyaringan tabrakan.
## [Kepemilikan jaringan](#kepemilikan-jaringan)
Untuk mendukung mekanisme fisik kompleks sambil juga menargetkan pengalaman lancar dan responsif bagi pemain, mesin fisika Roblox menggunakan sistem fisika terdistribusi di mana perhitungan didistribusikan antara server dan semua klien yang terhubung.Dalam sistem ini, mesin menugaskan kepemilikan jaringan dari fisik yang disimulasikan secara fisik ke klien atau server untuk membagi pekerjaan menghitung fisika.Lihat [Kepemilikan jaringan](/docs/id-id/physics/network-ownership) untuk rincian lebih lanjut.
## [Pengaturan waktu adaptif](#pengaturan-waktu-adaptif)
Mesin menekankan kinerja terbaik dengan secara otomatis menugaskan assemblies ke salah satu dari tiga tingkat simulasi.Untuk skenario yang memiliki mekanisme kompleks seperti tank, Anda dapat meningkatkan stabilitas dengan menetapkan langkah waktu tetap.Lihat [Pengaturan waktu adaptif](/docs/id-id/physics/adaptive-timestepping) untuk informasi lebih lanjut.
## [Sistem tidur](#sistem-tidur)
Ketika sebuah assemblasi tidak bergerak atau mempercepat, mesin fisika Roblox meningkatkan kinerja dengan secara otomatis menghentikan simulasi assemblasi.Lihat [Sistem tidur](/docs/id-id/physics/sleep-system) untuk deskripsi terperinci tentang sistem tidur.
| 95 |
https://create.roblox.com/docs/id-id/physics/assemblies
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
6. /
7. [Fisika](/docs/id-id/physics)
Bahasa Indonesia
Masukan
# Kumpulan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/physics/assemblies).
Sebuah kumpulan adalah satu atau lebih [bagian](/docs/id-id/parts) yang disatukan oleh baut kaku [WeldConstraint](/docs/id-id/reference/engine/classes/WeldConstraint) atau terhubung melalui engsel yang dapat dipindahkan, seperti [Motor6Ds](/docs/id-id/reference/engine/classes/Motor6D) .Anda dapat mengelompokkan kumpulan bagian dalam wadah model untuk dengan cepat mengatur bagian dan objek terkait sebagai aset tunggal.
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Block.png' alt='A light blue cube against a dark blue background that represents an assembly of 1 part.' title='' width='100%' height='' />
*1 pengumpulan; 1 bagian*
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Avatar.png' alt='A humanoid character model against a dark blue background that represents an assembly of 18 parts.' title='' width='100%' height='' />
*1 pengumpulan; 18 bagian*
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Example-Ship.png' alt='A pirate that represents an assemble of 179 parts.' title='' width='100%' height='' />
*1 pengumpulan; 179 bagian*
Dari perspektif fisika, sebuah assemblasi dianggap sebagai tubuh kaku tunggal , artinya tidak ada kekuatan yang dapat mendorong atau menarik bagian\-bagian terhubung satu sama lain, dan mereka akan bergerak sebagai satuan tunggal.Semua kekuatan yang diterapkan pada spesifik [BasePart](/docs/id-id/reference/engine/classes/BasePart) diterapkan ke kumpulannya \- kejadian, [BasePart:ApplyImpulse()](/docs/id-id/reference/engine/classes/BasePart#ApplyImpulse) menerapkan impuls ke kumpulan pada [BasePart.AssemblyCenterOfMass](/docs/id-id/reference/engine/classes/BasePart#AssemblyCenterOfMass) .
Sendi yang menggabungkan beberapa bagian menjadi kumpulan hanya aktif di [Workspace](/docs/id-id/reference/engine/classes/Workspace) atau instansi lain [WorldModel](/docs/id-id/reference/engine/classes/WorldModel).Jika bagian disimpan di tempat lain, semua las/koneksi yang menggabungkan bagian menjadi kumpulan tidak berfungsi.
Untuk melihat garis berwarna di sekitar bagian untuk memvisualisasikan kumpulan tubuh kaku tunggal, beralih pada Assemblies dari widget [Opsi Visualisasi](/docs/id-id/studio/ui-overview#visualization-options) di sudut kanan atas tampilan 3D.
## [Properti penyusunan](#properti-penyusunan)
Properti berikut [BasePart](/docs/id-id/reference/engine/classes/BasePart) menunjukkan data mengenai pengumpulannya.Nilai mereka akan sama untuk bagian mana pun dalam assemblasi yang sama, jadi tidak masalah bagian mana yang Anda gunakan.
| Propinsi | Deskripsi |
| --- | --- |
| [BasePart.AssemblyLinearVelocity](/docs/id-id/reference/engine/classes/BasePart#AssemblyLinearVelocity) | Vektor kecepatan linier dari penggabungan bagian.Mengatur kecepatan langsung dapat menyebabkan gerakan yang tidak realistis, jadi penggunaan batasan [VectorForce](/docs/id-id/reference/engine/classes/VectorForce) atau [LinearVelocity](/docs/id-id/reference/engine/classes/LinearVelocity) diperlukan, atau [BasePart:ApplyImpulse()](/docs/id-id/reference/engine/classes/BasePart#ApplyImpulse) untuk perubahan instan dalam kecepatan linier. |
| [BasePart.AssemblyAngularVelocity](/docs/id-id/reference/engine/classes/BasePart#AssemblyAngularVelocity) | Vektor kecepatan sudut dari penggabungan bagian.Mengatur kecepatan secara langsung dapat menyebabkan gerakan yang tidak realistis, jadi penggunaan batasan [Torque](/docs/id-id/reference/engine/classes/Torque) atau [AngularVelocity](/docs/id-id/reference/engine/classes/AngularVelocity) diperlukan, atau [BasePart:ApplyAngularImpulse()](/docs/id-id/reference/engine/classes/BasePart#ApplyAngularImpulse) untuk perubahan kecepatan sudut secara instan. |
| [BasePart.AssemblyCenterOfMass](/docs/id-id/reference/engine/classes/BasePart#AssemblyCenterOfMass) | Posisi hanya dibaca yang dihitung melalui massa dan posisi semua bagian dalam kumpulan.Kekuatan yang diterapkan ke pusat massa tidak akan menyebabkan akselerasi sudut, hanya linear. |
| [BasePart.AssemblyMass](/docs/id-id/reference/engine/classes/BasePart#AssemblyMass) | Jumlah dari [BasePart.Mass](/docs/id-id/reference/engine/classes/BasePart#Mass) dari semua bagian dalam kumpulan. Jika kumpulan memiliki bagian yang diikat, massa kumpulan dianggap tak terbatas. |
| [BasePart.AssemblyRootPart](/docs/id-id/reference/engine/classes/BasePart#AssemblyRootPart) | Bagian yang secara otomatis dipilih untuk mewakili bagian akar kumpulan [root](#assembly-root-part). |
## [Bagian akar pengumpulan](#bagian-akar-pengumpulan)
Setiap assemblasi memiliki bagian akar yang ditunjukkan oleh propertinya [AssemblyRootPart](/docs/id-id/reference/engine/classes/BasePart#AssemblyRootPart).Ini adalah bagian yang tidak bergerak saat [Motor6D](/docs/id-id/reference/engine/classes/Motor6D) transformasi diperbarui, serta bagian yang digunakan untuk menjaga konsistensi replikasi fisika dan kepemilikan jaringan.
Anda tidak dapat secara eksplisit mengatur bagian akar, tetapi faktor berikut memengaruhi probabilitas dari tertinggi ke terendah:
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Arrow-Higher.png' alt='' title='' width='50' height='' />Bagian [Anchored](/docs/id-id/reference/engine/classes/BasePart#Anchored) akan selalu ditugaskan sebagai bagian akar.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Arrow-High.png' alt='' title='' width='50' height='' />Bagian dengan [Massless](/docs/id-id/reference/engine/classes/BasePart#Massless) diatur ke palsu (默认) mendapat prioritas.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Arrow-Low.png' alt='' title='' width='50' height='' />Nilai yang lebih tinggi [RootPriority](/docs/id-id/reference/engine/classes/BasePart#RootPriority) memiliki prioritas.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Arrow-Lower.png' alt='' title='' width='50' height='' />Prioritas berdasarkan ukuran bagian, dengan pengganda untuk bagian dengan nama spesifik.
## [Perilaku ankerisasi](#perilaku-ankerisasi)
Ketika salah satu bagian dari sebuah kumpulan diikat, bagian itu menjadi bagian akar dan semua bagian lain secara implisit diikat dengannya.Sekuel berikut menunjukkan perilaku ini.
1. Di bawah ini, empat bagian disambung bersama dengan [WeldConstraints](/docs/id-id/reference/engine/classes/WeldConstraint) (garis hijau) untuk membentuk satu kumpulan, seperti yang ditunjukkan oleh garis berwarna cocok.
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Anchor-Diagram-1.png' alt='' title='' width='720' height='' />
*Empat bagian disambung menjadi satu kesatuan*
2. Jika hanya satu bagian dalam pengumpulan diikat, pengumpulan tidak akan berubah, selain bagian akar yang berpotensi berubah (bagian yang diikat selalu memiliki prioritas tertinggi [untuk menjadi bagian akar](#assembly-root-part)).
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Anchor-Diagram-2.png' alt='' title='' width='720' height='' />
*Bagian yang diikat (seperti yang ditunjukkan dengan ikon anker) menjadi bagian akar baru*
3. Jika lebih dari satu bagian diikat, kumpulan akan terbagi .Di bawah ini, bagian kiri dan atas keduanya diikat, sehingga penggabungan asli terbagi menjadi dua kumpulan seperti yang ditunjukkan oleh garis berwarna.Juga, [WeldConstraint](/docs/id-id/reference/engine/classes/WeldConstraint) antara dua assembli deaktif, karena Anda tidak dapat memiliki las aktif di antara dua assembli yang diikat.
<img src='https://prod.docsiteassets.roblox.com/assets/physics/assemblies/Assembly-Anchor-Diagram-3.png' alt='' title='' width='720' height='' />
*Dua assemblasi dengan bagian terpasang sebagai bagian akar masing\-masing*
Jika Anda ingin mengaitkan semua bagian dalam satu kumpulan, Anda hanya perlu mengaitkan bagian akar kumpulan.Mengaitkan semua bagian sebenarnya kurang efisien, karena membuat lebih banyak kumpulan.
| 96 |
https://create.roblox.com/docs/id-id/physics/network-ownership
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
6. /
7. [Fisika](/docs/id-id/physics)
Bahasa Indonesia
Masukan
# Kepemilikan jaringan
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/physics/network-ownership).
Untuk mendukung mekanisme fisik kompleks sambil juga menargetkan pengalaman lancar dan responsif bagi pemain, mesin fisika Roblox menggunakan sistem fisika terdistribusi di mana perhitungan didistribusikan antara server dan semua klien yang terhubung.Dalam sistem ini, mesin menugaskan kepemilikan jaringan dari fisik disimulasikan ke klien atau server untuk membagi pekerjaan menghitung fisika.
Klien mengalami lebih responsif interaksi fisik dengan bagian yang mereka memiliki, karena tidak ada kelambatan dari komunikasi dengan server.Kepemilikan jaringan juga meningkatkan kinerja server karena perhitungan fisika dapat dibagi di antara klien individu, memungkinkan server untuk memprioritaskan tugas lain.
## [Kepemilikan Bagian Dasar](#kepemilikan-bagian-dasar)
Secara default, server mempertahankan kepemilikan dari [BasePart](/docs/id-id/reference/engine/classes/BasePart).Selain itu, server selalu memiliki terikat [BaseParts](/docs/id-id/reference/engine/classes/BasePart) dan Anda tidak dapat secara manual mengubah kepemilikannya.
Berdasarkan kapasitas hardware klien dan kedekatan pemain [Player.Character](/docs/id-id/reference/engine/classes/Player#Character) terhadap bagian yang tidak diikat [BasePart](/docs/id-id/reference/engine/classes/BasePart), mesin secara otomatis menugaskan kepemilikan bagian itu kepada klien.Dengan demikian, bagian yang dekat dengan karakter pemain lebih mungkin menjadi milik pemain.
## [Kepemilikan kumpulan](#kepemilikan-kumpulan)
Jika mekanisme berbasis fisika tidak memiliki bagian yang diikat, [menetapkan kepemilikan](#setting-ownership) pada kumpulan [assemble](/docs/id-id/physics/assemblies) dalam mekanisme tersebut menetapkan kepemilikan yang sama untuk setiap assemble dalam mekanisme.
Jika Anda mengaitkan kumpulan tunggal yang bukan bagian dari mekanisme yang lebih luas, kepemilikannya pergi ke server, karena server selalu memiliki yang diberikan [BaseParts](/docs/id-id/reference/engine/classes/BasePart) .Setelah melepaskan kumpulan yang sama, status kepemilikan sebelumnya hilang dan kembali ke penanganan otomatis oleh mesin.
Jika Anda mengaitkan satu kumpulan dalam mekanisme kumpulan yang lebih luas, kepemilikannya pergi ke server, tetapi kepemilikan kumpulan lainnya tetap tidak berubah.Menyingkirkan asamblasi yang sama membalikkan kepemilikan yang sebelumnya ditetapkan.
## [Mengatur kepemilikan](#mengatur-kepemilikan)
Dalam pengalaman dengan interaksi fisika kompleks atau dalam kasus di mana Anda perlu menugaskan kontrol langsung, Anda dapat mengatur kepemilikan melalui panggilan sisi server ke [BasePart:SetNetworkOwner()](/docs/id-id/reference/engine/classes/BasePart#SetNetworkOwner) .
Meskipun Anda dapat secara manual memanggil [SetNetworkOwner(nil)](/docs/id-id/reference/engine/classes/BasePart#SetNetworkOwner) untuk server untuk objek gameplay\-kritis yang seharusnya tidak dapat dimanipulasi oleh klien, Anda harus melakukannya secara konservatif karena dapat menyebabkan interaksi fisika gugup untuk klien.:
Perhatikan juga bahwa server selalu memiliki terikat [BaseParts](/docs/id-id/reference/engine/classes/BasePart) dan Anda tidak dapat secara manual mengubah kepemilikannya.Pertimbangkan kendaraan yang memiliki objek [VehicleSeat](/docs/id-id/reference/engine/classes/VehicleSeat) untuk pengemudi dan objek [Seat](/docs/id-id/reference/engine/classes/Seat) untuk penumpang, keduanya termasuk dalam pengumpulan kendaraan.Dengan aturan kepemilikan default, jika karakter pemain duduk di [Seat](/docs/id-id/reference/engine/classes/Seat) (penumpang) dan kemudian pemain lain melompat ke [VehicleSeat](/docs/id-id/reference/engine/classes/VehicleSeat) (pengemudi), penumpang mendapatkan kepemilikan fisik seluruh kendaraan karena mereka masuk lebih dulu.Pengemudi harus menunggu beberapa siklus jaringan sebelum input mereka diakui dan kendaraan akan terasa kurang responsif.
Perbaikan berikut [Script](/docs/id-id/reference/engine/classes/Script) memperbaiki ini dengan secara manual memberikan kepemilikan jaringan kepada pengemudi.Di dalamnya, [VehicleSeat](/docs/id-id/reference/engine/classes/VehicleSeat) menetapkan [Occupant](/docs/id-id/reference/engine/classes/VehicleSeat#Occupant) ke [Humanoid](/docs/id-id/reference/engine/classes/Humanoid) di atasnya, sehingga skrip mendengarkan peristiwa kursi [Changed](/docs/id-id/reference/engine/classes/Instance#Changed) untuk menangkap saat pemain duduk di kursi.Saat pengemudi meninggalkan kursi, kepemilikan jaringan kendaraan dikembalikan ke otomatis dengan [BasePart:SetNetworkOwnershipAuto()](/docs/id-id/reference/engine/classes/BasePart#SetNetworkOwnershipAuto) .
```
---
```
local Players = game:GetService("Players")
local vehicleSeat = script.Parent
vehicleSeat.Changed:Connect(function(prop)
if prop == "Occupant" then
local humanoid = vehicleSeat.Occupant
if humanoid then
-- Dapatkan pemain dari karakter
local player = Players:GetPlayerFromCharacter(humanoid.Parent)
if player then
vehicleSeat:SetNetworkOwner(player)
end
else
-- Atur ulang kepemilikan saat kursi tidak ditempati
vehicleSeat:SetNetworkOwnershipAuto()
end
end
end)
```
```
Untuk kinerja lancar dan perilaku responsif, pastikan Anda juga menugaskan kepemilikan dari setiap longgar [BaseParts](/docs/id-id/reference/engine/classes/BasePart) di atas kendaraan ke klien yang sama yang mengontrol kendaraan.
## [Menggambarkan kepemilikan](#menggambarkan-kepemilikan)
Untuk membantu dalam debugging kepemilikan jaringan, Studio dapat menampilkan garis berwarna di sekitar objek saat pengujian.
[https://prod.docsiteassets.roblox.com/assets/physics/network-ownership/Visualization-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/network-ownership/Visualization-Demo.mp4)
| Warna garis besar | | Deskripsi |
| --- | --- | --- |
| | (hijau) | Klien Anda memiliki bagian dan menyimpulkannya. |
| | (merah) | Bagiannya berada di "zona buffer" di mana klien Anda menyimpannya tetapi masih dimiliki oleh sesuatu yang lain.Klien Anda mungkin mendapatkan kepemilikan setelah ini, atau mungkin menolak. |
| | (putih/abu\-abu) | Server atau klien lain memiliki bagian melalui kepemilikan jaringan otomatis atau dari penugasan eksplisit melalui [part:SetNetworkOwner()](/docs/id-id/reference/engine/classes/BasePart#SetNetworkOwner). |
Perhatikan bahwa dalam simulasi multi\-klien , setiap klien diberi warna unik untuk menunjukkan kepemilikan mereka; ini dicerminkan dalam pandangan Server , membantu Anda menentukan klien mana yang memiliki bagian mana (s) pada waktu tertentu.
Untuk mengaktifkan visualisasi kepemilikan jaringan:
1. Klik tombol opsional visualisasi di sudut kanan atas tampilan 3D.
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Visualization-Options.png' alt='A close up view of the 3D viewport with the Visualization Options button indicated in the upper-right corner.' title='' width='780' height='' />
2. Di menu dropdown, beralih pada pemilik jaringan .
## [Kekhawatiran keamanan](#kekhawatiran-keamanan)
Roblox tidak dapat memverifikasi perhitungan fisika saat klien memiliki kepemilikan atas [BasePart](/docs/id-id/reference/engine/classes/BasePart) .Klien dapat memanfaatkan ini dan mengirim data buruk ke server, seperti teleportasi [BasePart](/docs/id-id/reference/engine/classes/BasePart), membuatnya melewati dinding atau terbang di sekitar.
Selain itu, peristiwa terikat pada kepemilikan jaringan, yang berarti bahwa klien dapat menembakkan peristiwa di jaringan yang dimilikinya dan mengirimkannya ke server, bahkan jika server tidak melihatnya menyentuh apa pun.Sebagai contoh, klien dapat menimbulkan kerusakan pada pedang ke pemain lain di peta dengan menembakkan peristiwa melalui suntikan skrip, jadi penting untuk memeriksa validitas peristiwa seperti itu yang ditembakkan oleh klien.
Lihat [Taktik Keamanan dan Penghindaran Penipuan](/docs/id-id/scripting/security/security-tactics) untuk taktik keamanan dan penghindaran penipuan terperinci untuk pengalaman Roblox.
| 97 |
https://create.roblox.com/docs/id-id/physics/mechanical-constraints
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
6. /
7. [Fisika](/docs/id-id/physics)
8. /
9. [Constraint Mekanis](/docs/id-id/physics/mechanical-constraints)
Bahasa Indonesia
Masukan
# Kontraksi mekanik
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/physics/mechanical-constraints).
Mesin fisika termasuk berikut [Constraints](/docs/id-id/reference/engine/classes/Constraint) yang berperilaku sebagai koneksi mekanik konsep, termasuk engsel, resor, tali, dan banyak lagi.Selain itu, berbagai [batas penggerak](/docs/id-id/physics/mover-constraints) tersedia untuk memberikan gaya arah atau rotasi pada [kumpulan](/docs/id-id/physics/assemblies).
[Soket Bola](/docs/id-id/physics/constraints/ball-socket)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/BallInSocket-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/BallInSocket-Demo.mp4)
*[BallSocketConstraint](/docs/id-id/physics/constraints/ball-socket) memaksakan dua lampirannya ke posisi yang sama dan memungkinkan mereka untuk berputar bebas di semua tiga sumbu, dengan batas opsional untuk membatasi kemiringan dan putaran*
[Sendi](/docs/id-id/physics/constraints/hinge)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Hinge-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Hinge-Demo.mp4)
*[Kekuatan engsel](/docs/id-id/physics/constraints/hinge) memungkinkan dua lampirannya untuk berputar sekitar satu sumbu, dengan kekuatan opsional yang ditugaskan untuk perilaku motor atau servo*
[Prismatik](/docs/id-id/physics/constraints/prismatic)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Prismatic-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Prismatic-Demo.mp4)
*[Batasan Prismatik](/docs/id-id/physics/constraints/prismatic) memungkinkan dua lampiran untuk meluncur di sepanjang satu sumbu tetapi tidak berputar, dengan kekuatan opsional yang ditugaskan untuk mekanisme seperti pintu geser dan platform lift*
[Silindris](/docs/id-id/physics/constraints/cylindrical)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Cylindrical-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Cylindrical-Demo.mp4)
*[Batas Silindris](/docs/id-id/physics/constraints/cylindrical) memungkinkan lampirannya untuk meluncur di sepanjang satu sumbu dan berputar di sekitar sumbu lain, dengan kekuatan sudut dan/atau linier opsional yang ditugaskan*
[Musim Semi](/docs/id-id/physics/constraints/spring)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Spring-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Spring-Demo.mp4)
*[Batasan Musim Semi](/docs/id-id/physics/constraints/spring) menerapkan kekuatan pada lampirannya berdasarkan perilaku musim semi dan peredam, dengan panjang minimum / maksimum opsional*
[Musim Semi Torsi](/docs/id-id/physics/constraints/torsion-spring)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/TorsionSpring-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/TorsionSpring-Demo.mp4)
*[Batasan Musim Semi Torsi](/docs/id-id/physics/constraints/torsion-spring) berlaku torque berdasarkan sudut relatif dan kecepatan sudut relatif, dalam upaya untuk membawa dua sumbu dari dua bagian bersama\-sama*
[Universel](/docs/id-id/physics/constraints/universal)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Universal-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Universal-Demo.mp4)
*[Batasan Universal](/docs/id-id/physics/constraints/universal) memastikan dua sumbu pada dua kumpulan tetap berpendam, berguna untuk aplikasi seperti transmisi daya kendaraan ke sumbu penggerak belakang, robotika, dan banyak lagi*
[Tali](/docs/id-id/physics/constraints/rope)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Rope-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Rope-Demo.mp4)
*[Batasan Tali](/docs/id-id/physics/constraints/rope) mencegah dua lampiran terpisah lebih jauh dari panjang yang didefinisikan, dengan perilaku opsional sebagai winch ekstensi atau kontraksi*
[Batang](/docs/id-id/physics/constraints/rod)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Rod-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Rod-Demo.mp4)
*[Batas Rod](/docs/id-id/physics/constraints/rod) menyimpan dua lampiran terpisah dengan panjang yang didefinisikan, dengan batas opsional pada kemiringan rotasi*
[Pesawat](/docs/id-id/physics/constraints/plane)[https://prod.docsiteassets.roblox.com/assets/physics/constraints/Plane-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/Plane-Demo.mp4)
*[Batasan Pesawat](/docs/id-id/physics/constraints/plane) memindahkan dua lampiran ke posisi/orientasi di sepanjang pesawat, dan kedua lampiran tetap bebas untuk diterjemahkan dan diputar kecuali terkendala lainnya*
[Lasar](/docs/id-id/physics/constraints/weld)
*[Kekuatan las](/docs/id-id/physics/constraints/weld) terhubungkan dua [BaseParts](/docs/id-id/reference/engine/classes/BasePart) dan memastikan mereka tetap berada di posisi dan orientasi relatif yang sama satu sama lain, bahkan jika mereka tidak menyentuh*
[Tegak](/docs/id-id/physics/constraints/rigid)
*[Batasan Kaku](/docs/id-id/physics/constraints/rigid) terhubung dua [Attachments](/docs/id-id/reference/engine/classes/Attachment) atau [Bones](/docs/id-id/reference/engine/classes/Bone) dan memastikan mereka tetap berada di posisi/orientasi relatif yang sama satu sama lain, bahkan jika mereka tidak menyentuh*
[Tidak Ada Tabrakan](/docs/id-id/physics/constraints/no-collision)
*[Tidak ada batasan tabrakan](/docs/id-id/physics/constraints/no-collision) mencegah tabrakan antara dua bagian spesifik, tetapi bagian\-bagian itu masih dapat mendaftarkan tabrakan dengan sisa dunia*
## [Visualisasi batasan](#visualisasi-batasan)
Untuk akurat menggambarkan keterbatasan di Studio, Anda dapat menggunakan opsi berikut dari tab Model di bilah alat:
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Constraints-Section-Labeled.png' alt='Constraints tools indicated in Model tab' title='' width='754' height='' /><img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-A.png' alt='' title='' width='40' height='' />Tampilkan Lasan — Tampilkan [WeldConstraints](/docs/id-id/reference/engine/classes/WeldConstraint), secara terpisah dari visualisasi batasan lainnya.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-B.png' alt='' title='' width='40' height='' />Detail Batasan — Tampilkan detil visual lengkap dari batasan non\-pengelasan.
<img src='https://prod.docsiteassets.roblox.com/assets/misc/Box-Label-C.png' alt='' title='' width='40' height='' />Skala — Skala relatif visualisasi.
Selain visualisasi di atas, Anda dapat melihat garis berwarna di sekitar mekanisme (kelompok bagian yang berbagi langkah simulasi dan [kepemilikan jaringan](/docs/id-id/physics/network-ownership) ) dengan beralih pada Mekanisme dari widget [Opsi Visualisasi](/docs/id-id/studio/ui-overview#visualization-options) di sudut kanan atas tampilan 3D.
## [Buat batasan](#buat-batasan)
Semua batasan mekanis harus terhubung satu atau dua [Attachments](/docs/id-id/reference/engine/classes/Attachment) atau [Bones](/docs/id-id/reference/engine/classes/Bone) , kecuali untuk [WeldConstraint](/docs/id-id/physics/constraints/weld) dan [NoCollisionConstraint](/docs/id-id/physics/constraints/no-collision) .Ketika terhubung ke [Bones](/docs/id-id/reference/engine/classes/Bone) , batasan akan menggunakan posisi dan orientasi animasi mereka.
Untuk membuat batasan mekanis, Anda dapat menggunakan alat Buat atau jendela [Penjelajah](/docs/id-id/studio/explorer).
Buat alat
Penjelajah
1. Di tab Model di bilah alat, akses menu pemilih tombol Buat dan pilih jenis batasan yang diinginkan, misalnya Musim Semi .
<img src='https://prod.docsiteassets.roblox.com/assets/studio/general/Model-Tab-Constraints-Create-Menu.png' alt='Constraint picker indicated in Studio toolbar' title='' width='754' height='' />
2. Di jendela pandang 3D, lerap di atas apa pun [Part](/docs/id-id/reference/engine/classes/Part) atau [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) dan klik untuk menambahkan baru [Attachment](/docs/id-id/reference/engine/classes/Attachment) ke bagian di titik visualisasi.Alternatifnya, hover over dan klik yang sudah ada [Attachment](/docs/id-id/reference/engine/classes/Attachment) atau [Bone](/docs/id-id/reference/engine/classes/Bone) untuk menggunakannya untuk kondisi batasan.
3. Kebanyakan batasan mekanis memerlukan lampiran sekunder dalam fungsionalitasnya, sehingga alat akan biasanya meminta Anda untuk mengulangi langkah sebelumnya di lain [Part](/docs/id-id/reference/engine/classes/Part) , [MeshPart](/docs/id-id/reference/engine/classes/MeshPart) , [Attachment](/docs/id-id/reference/engine/classes/Attachment) , atau [Bone](/docs/id-id/reference/engine/classes/Bone) .
<img src='https://prod.docsiteassets.roblox.com/assets/physics/constraints/Creation-Diagram.jpg' alt='SpringConstraint connecting two attachments on separate blocks. One block is green and the other is blue.' title='' width='600' height='' />
*Selesai [Batasan Musim Semi](/docs/id-id/physics/constraints/spring) menghubungkan dua lampiran*
## [Simulasi fisik](#simulasi-fisik)
Untuk menyimulasikan fisika saat [bergerak](/docs/id-id/parts#move) atau [berputar](/docs/id-id/parts#rotate) bagian, Anda dapat beralih ke mode Fisik di bilah alat Studio, secara efektif memaksa bagian untuk mematuhi batasan fisik.Sebagai contoh, jika dua bagian dilampirkan oleh [Batas Tali](/docs/id-id/physics/constraints/rope) dan Anda menyeret satu bagian di sekitar adegan, bagian lain akan mengikuti saat tali menjadi tegang.
<img src='https://prod.docsiteassets.roblox.com/assets/physics/constraints/Model-Tab-Mode-Physical.png' alt='' title='' width='670' height='' />
| 98 |
https://create.roblox.com/docs/id-id/physics/constraints/ball-socket
|
id-id
|
1. [Buat](/docs/id-id/platform)
2. /
3. [Pengalaman Virtual](/docs/id-id/experiences)
4. /
5. [Workspace 3D](/docs/id-id/workspace)
6. /
7. [Fisika](/docs/id-id/physics)
8. /
9. [Constraint Mekanis](/docs/id-id/physics/mechanical-constraints)
Bahasa Indonesia
Masukan
# socket bola
\*Konten ini diterjemahkan menggunakan AI (Beta) dan mungkin mengandung kesalahan. Untuk melihat halaman ini dalam bahasa Inggris, klik [di sini](/docs/en-us/physics/constraints/ball-socket).
Untuk panduan tentang pembuatan, visualisasi, dan simulasi batasan mekanis, termasuk [BallSocketConstraint](/docs/id-id/reference/engine/classes/BallSocketConstraint) , lihat [Batasan mekanis](/docs/id-id/physics/mechanical-constraints) .Lihat juga [unit Roblox](/docs/id-id/physics/units) untuk memahami bagaimana unit Roblox dibandingkan dengan unit metrik.
A [BallSocketConstraint](/docs/id-id/reference/engine/classes/BallSocketConstraint) memaksakan dua lampirannya ke posisi yang sama dan memungkinkan mereka untuk berputar bebas di semua tiga sumbu.Namun, Anda dapat mengaktifkan batasan untuk membatasi kemiringan dan putaran.
[https://prod.docsiteassets.roblox.com/assets/physics/constraints/BallInSocket-Demo.mp4](https://prod.docsiteassets.roblox.com/assets/physics/constraints/BallInSocket-Demo.mp4)
## [Batasan](#batasan)
Anda dapat mengatur batas untuk membatasi kedua tilt dan twist dari soket bola, mirip dengan cara kepala manusia bisa miring dan berputar dalam rentang axial terbatas.Mengaktifkan properti memperlihatkan nilai untuk membatasi miring di dalam kerucut; itu juga mengekspos properti yang, saat diaktifkan, memungkinkan Anda membatasi putaran rotasi melalui batas dan .
*Sudut Atas \= 30 \>*
*Batas TwistDisabled \= benar \>*
Mengaktifkan [LimitsEnabled](/docs/id-id/reference/engine/classes/BallSocketConstraint#LimitsEnabled) juga mengekspos nilai [Restitution](/docs/id-id/reference/engine/classes/BallSocketConstraint#Restitution) yang mendefinisikan elastisitas lampiran pada batas miring dan/atau putaran mereka.
Ketika [LimitsEnabled](/docs/id-id/reference/engine/classes/BallSocketConstraint#LimitsEnabled) diaktifkan, orientasi lampiran soket bola mempengaruhi cara berputarnya.Untuk memastikan rotasi terjadi di sekitar sumbu yang diinginkan, setiap lampiran [Axis](/docs/id-id/reference/engine/classes/Attachment#Axis) , yang diceritakan oleh panah kuning, harus menunjuk ke arah yang sama.
| 99 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.