Een SkateboardPlatform kan worden gebruikt om een skateboard te maken. Wanneer personages op een skateboard stappen, zijn ze eraan vastgeplakt totdat ze de escape-toets indrukken. Tot die tijd gebruikt het personage skateboardanimaties en reist het sneller dan een wandelend personage.


Wordt geactiveerd wanneer het skateboard is uitgerust.


SkateboardPlatform.Equipped

humanoid

De `Class.Humanoid` die is gekoppeld aan het personage dat het skateboard uitrust.


skateboardController

SkateboardPlatform.equipped

Wordt geactiveerd wanneer de `Class.SkateboardPlatform.ControllingHumanoid` van het SkateboardPlatform de kracht verandert die op het SkateboardPlatform wordt gebruikt.


SkateboardPlatform.MoveStateChanged

newState

oldState

Wordt geactiveerd wanneer het skateboard wordt uitgepakt.


SkateboardPlatform.Unequipped

De `Class.Humanoid` die is gekoppeld aan het personage dat het skateboard heeft uitgepakt.


SkateboardPlatform.unequipped

Voegt ''impulseWorld'' toe aan de `Class.BasePart.Velocity` van het SkateboardPlatform.


SkateboardPlatform:ApplySpecificImpulse

impulseWorld

SkateboardPlatform

De actieve SkateboardController van het SkateboardPlatform.


SkateboardPlatform.Controller

De `Class.Humanoid` die het SkateboardPlatform bestuurt.


SkateboardPlatform.ControllingHumanoid

De bewegingsrichting, gekoppeld aan de toetsen A en D. Moet 1 (rechts), 0 (recht) of -1 (links) zijn. Zal terugverversen naar 0 tenzij constant ingesteld.


SkateboardPlatform.Steer

Als waar, zullen de wielen niet rollen zonder gebruikersinvoer.


SkateboardPlatform.StickyWheels

De bewegingsrichting, gekoppeld aan de toetsen W en S. Moet een geheel getal zijn 1 (vooruit), 0 (null), of -1 (achteruit). Zal terugverversen naar 0 tenzij constant ingesteld.


SkateboardPlatform.Throttle

Het script hieronder genereert een nieuwe `Part` instantie en stelt verschillende eigenschappen van het deel in.

Het meest opvallende is dat het script de `Class.Part.Shape` eigenschap instelt op
`Enum.PartType.Ball`. Het geeft het deel ook de naam _JurassicPart_, verankert het, maakt
het een kind van _Workspace_, en stelt de kleur in op wit.


Het Part-object is een type `Class.BasePart`. Het komt in vijf verschillende
primitieve vormen: Bal, Blok, Cilinder, Wig, en Hoekwig.


Part

De Shape-eigenschap stelt de algehele vorm van het object in op een van een
vooraf bepaalde lijst van ingebouwde vormen.

De `Enum.PartType` enum controleert de vormwaarde en heeft vijf mogelijke
vormen:

| Vorm/Waarde | Beschrijving                             |
| ----------- | --------------------------------------- |
| Bal        | Een sferische vorm.                      |
| Blok       | Een blokvorm.                            |
| Cilinder    | Een cilinder vorm.                       |
| Wig        | Een wigvorm met een helling aan één kant. |
| Hoekwig    | Een wigvorm met hellingen aan twee zijden. |

`Class.MeshPart` en [solide modellering](/parts/solid-modeling)
kunnen worden gebruikt om volledig aangepaste deelvormen te verkrijgen.

Botsingen tussen ballen, blokken en wiggen, en hoekwiggen zijn exact,
terwijl botsingen tussen terrein, cilinders, TriangleMeshes en andere
geometrie typen benaderingen zijn. Dit betekent dat de balvorm nuttig kan zijn
om stabiele colliders voor autowielen te creëren.


Part.Shape

Stelt de algehele vorm van het object in.


Een veelvoorkomend type `Class.BasePart` dat in verschillende primitieve vormen voorkomt.


De FormFactorPart-klasse is een abstracte klasse. Het erft van de
`Class.BasePart` klasse en voegt de `Class.FormFactorPart.FormFactor` eigenschap
toe aan klassen die ervan erven.


FormFactorPart

Dit werd gebruikt om een rasterbeperking van de grootte van het onderdeel op te geven. Doet nu niets meer.


FormFactorPart.FormFactor

Bepaalt hoe een onderdeel zich gedraagt wanneer het wordt vergroot of verkleind en de waarden die zijn grootte kan aannemen.


FormFactorPart.formFactor

De FormFactorPart-klasse is een abstracte klasse. Het erft van de BasePart
klasse en voegt de FormFactor-eigenschap toe aan klassen die ervan erven.


Maakt een blauwe part en een rode doelpart. De blauwe part zal proberen om soepel
het rode doel te bereiken. Beweeg en roteer het doel om het gedrag te zien.
Het veranderen van de smoothTime zal resulteren in verschillende soepelheidsnelheden.


`Class.BasePart` is een abstracte basis klasse voor objecten in de wereld die renderen
en fysiek worden gesimuleerd terwijl ze in de `Class.Workspace` zijn. Er zijn verschillende
implementaties van `Class.BasePart`, de meest voorkomende zijn `Class.Part` en
`Class.MeshPart`. Andere zijn `Class.WedgePart`, `Class.SpawnLocation`, en
de singleton `Class.Terrain` object. Over het algemeen, wanneer documentatie verwijst naar
een "deel," zullen de meeste `Class.BasePart` implementaties werken en niet alleen
`Class.Part`.

Voor informatie over hoe `Class.BasePart|BaseParts` worden gegroepeerd in gesimuleerde
stijve lichamen, zie [Assemblies](/physics/assemblies).

Er zijn veel verschillende objecten die interageren met `Class.BasePart` (anders dan
`Class.Terrain`), inclusief:

- Verschillende `Class.BasePart|BaseParts` kunnen binnen een `Class.Model` worden gegroepeerd en
  tegelijkertijd worden verplaatst met `Class.PVInstance:PivotTo()`. Zie
  [Models](/parts/models).
- Een `Class.Decal` past een uitgerekte afbeeldingsstructuur toe op de vlakken van een
  `Class.BasePart`, terwijl een `Class.Texture` een getegelde afbeeldingsstructuur toepast op
  de vlakken. Zie [Textures and Decals](/parts/textures-decals).
- Een `Class.SurfaceGui` rendert `Class.GuiObject|GuiObjects` op het vlak van een
  deel. Zie
  [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` kunnen aan een `Class.BasePart` worden toegevoegd om
  `Datatype.CFrame|CFrames` ten opzichte van het deel te specificeren. Deze worden vaak gebruikt door
  fysieke `Class.Constraint` objecten zoals beschreven in
  [Mechanical Constraints](/physics/mechanical-constraints) en
  [Mover Constraints](/physics/mover-constraints).
- `Class.ParticleEmitter` objecten stoten deeltjes uniform uit in het volume van
  de `Class.BasePart` waaraan ze zijn gekoppeld. Zie
  [Particle Emitters](/effects/particle-emitters).
- Lichtobjecten zoals `Class.PointLight` stoten licht uit vanuit het midden van een
  `Class.BasePart` zoals geïllustreerd in
  [Light Sources](/effects/light-sources).
- Als het is gekoppeld aan een `Class.Tool` en de naam **Handle** heeft, kan een
  `Class.BasePart` worden vastgehouden door personages. Zie
  [In-Experience Tools](/players/tools).


Vuurd wanneer een ander onderdeel in contact komt met een ander object. Deze gebeurtenis
stuurt alleen gegevens naar de client die deze op de hoogte stelt dat twee onderdelen zijn gebotst,
terwijl `Class.BasePart.Touched` gegevens naar de server stuurt.


BasePart.LocalSimulationTouched

part

Het andere onderdeel dat in contact kwam met dit onderdeel.


Vuurd op de lokale client wanneer een ander onderdeel in contact komt met dit
onderdeel.


Vuurd als het uiterlijk van het onderdeel wordt beïnvloed door de `Class.Shirt` klasse.


BasePart.OutfitChanged

Vuurd wanneer het uiterlijk van het onderdeel verandert door een `Class.Shirt`.


Verouderd. Vuurd op de lokale client wanneer een onderdeel stopt met het aanraken van een ander
onderdeel, onder omstandigheden die vergelijkbaar zijn met die van `Class.BasePart.TouchEnded`.
Deze gebeurtenis is de client-only tegenhanger van `Class.BasePart.TouchEnded`:
het stelt alleen de lokale client op de hoogte dat de twee onderdelen zijn gescheiden,
terwijl `Class.BasePart.TouchEnded` ook gegevens naar de server stuurt. Gebruik
`Class.BasePart.TouchEnded` in plaats daarvan.


BasePart.StoppedTouching

otherPart

Het andere onderdeel dat stopte met het aanraken van het gegeven onderdeel.


Vuurd op de lokale client wanneer een onderdeel stopt met het aanraken van een ander onderdeel.


Dit codevoorbeeld maakt een BillboardGui op een onderdeel dat het aantal
onderdelen weergeeft dat momenteel ermee in contact is.


Dit codevoorbeeld toont aan hoe je de `Class.BasePart.Touched`
evenement van meerdere onderdelen in een `Class.Model` met één functie kunt verbinden.


De **Touched** gebeurtenis vuurt wanneer een onderdeel in contact komt met een ander
onderdeel. Bijvoorbeeld, als **PartA** tegen **PartB** botst, dan
`Class.BasePart.Touched|PartA.Touched` vuurt met **PartB**, en
`Class.BasePart.Touched|PartB.Touched` vuurt met **PartA**.

Deze gebeurtenis vuurt alleen als gevolg van fysieke beweging, dus het zal niet
vuren als de `Class.BasePart.CFrame|CFrame` eigenschap is veranderd zodat
het onderdeel een ander onderdeel overlapt. Dit betekent ook dat ten minste een van de
onderdelen die betrokken zijn **niet** `Class.BasePart.Anchored|Anchored` moet zijn op het
moment van de botsing.

Deze gebeurtenis werkt samen met
`Class.Workspace.TouchesUseCollisionGroups` om te specificeren of
[botsingsgroepen](/workspace/collisions#collision-filtering)
worden erkend voor detectie.


BasePart.Touched

Het andere onderdeel dat in contact kwam met het gegeven onderdeel.


Vuurd wanneer een onderdeel een ander onderdeel aanraakt als gevolg van fysieke beweging.


Vuurd wanneer een onderdeel stopt met het aanraken van een ander onderdeel onder vergelijkbare omstandigheden als
bij `Class.BasePart.Touched`.

Deze gebeurtenis werkt samen met
`Class.Workspace.TouchesUseCollisionGroups` om te specificeren of
[botsingsgroepen](/workspace/collisions#collision-filtering)
worden erkend voor detectie.


BasePart.TouchEnded

Het andere onderdeel dat stopte met het aanraken van dit onderdeel.


Vuurd wanneer een onderdeel stopt met het aanraken van een ander onderdeel als gevolg van fysieke
beweging.


Demonstrates `Class.BasePart:AngularAccelerationToTorque()`.


Geeft de wereldruimte koppelvector terug die op de assemblage van het onderdeel moet worden toegepast om de opgegeven hoeksversnelling te bereiken. Dit resultaat kan worden gebruikt om het koppel te bepalen dat moet worden toegepast via een `Class.Torque`-instantie of `Class.BasePart:ApplyAngularImpulse()`.

De berekening gebruikt de rotatievergelijking van Euler waarbij _I_ de wereldruimte inertietensor van de assemblage is, _α_ de gewenste hoeksversnelling is, en _ω_ de hoeksnelheid is.

_τ = I · α + ω × (I · ω)_

Als het onderdeel geen afstammeling is van `Class.Workspace`, retourneert deze methode een vector van oneindigheid. Als de assemblage is verankerd, retourneert deze ook een vector van oneindigheid.

#### Gyroscopische Effecten

Wanneer een draaiende assemblage een asymmetrische inertietensor heeft, wordt het koppel dat nodig is om een opgegeven hoeksversnelling te bereiken, vergroot door de veranderende oriëntatie van het lichaam. De optionele `angVelocity`-parameter houdt rekening met deze gyroscopische effecten. Als weggelaten, worden deze gyroscopische effecten weggelaten uit de berekening.


BasePart:AngularAccelerationToTorque

angAcceleration

De gewenste hoeksversnelling vector in wereldruimte.


angVelocity

De huidige hoeksnelheid van de assemblage in wereldruimte. Standaard is dit `(0, 0, 0)`. Geef de hoeksnelheid van de assemblage op om rekening te houden met gyroscopische effecten.


Een `Datatype.Vector3` die het wereldruimte koppel vertegenwoordigt dat nodig is om de opgegeven hoeksversnelling te produceren.


Geeft het koppel terug dat nodig is om een gegeven hoeksversnelling op de assemblage van dit onderdeel te bereiken, met optionele rekening houdend met gyroscopische effecten.


Past een instantane hoeks krachtimpuls toe op de assemblage van dit onderdeel, waardoor de assemblage gaat draaien.

De resulterende hoeksnelheid van de impuls is afhankelijk van de `Class.BasePart.AssemblyMass|massa` van de assemblage. Dus een hogere impuls is nodig om zwaardere assemblages te verplaatsen. Impulsen zijn nuttig voor gevallen waarin je een kracht onmiddellijk wilt toepassen, zoals een explosie of botsing.

Als het onderdeel [eigendom](/physics/network-ownership) is van de server, moet deze functie worden aangeroepen vanuit een server `Class.Script` (niet vanuit een `Class.LocalScript` of een `Class.Script` met
`Class.BaseScript.RunContext|RunContext` ingesteld op `Enum.RunContext.Client`).
Als het onderdeel eigendom is van een client via **automatische** eigendom, kan deze functie worden aangeroepen vanuit zowel een clientscript **als** een serverscript; het aanroepen vanuit een clientscript voor een server-eigendom onderdeel heeft geen effect.


BasePart:ApplyAngularImpulse

impulse

Een hoeksimpuls vector die op de assemblage moet worden toegepast.


Pas een hoeksimpuls toe op de assemblage.


Deze functie past een instantane krachtimpuls toe op de assemblage van dit onderdeel.

De kracht wordt toegepast op het `Class.BasePart.AssemblyCenterOfMass|centrum van massa` van de assemblage, zodat de resulterende beweging alleen lineair zal zijn.

De resulterende snelheid van de impuls is afhankelijk van de `Class.BasePart.AssemblyMass|massa` van de assemblage. Dus een hogere impuls is nodig om zwaardere assemblages te verplaatsen. Impulsen zijn nuttig voor gevallen waarin je een kracht onmiddellijk wilt toepassen, zoals een explosie of botsing.

Als het onderdeel [eigendom](/physics/network-ownership) is van de server, moet deze functie worden aangeroepen vanuit een server `Class.Script` (niet vanuit een `Class.LocalScript` of een `Class.Script` met
`Class.BaseScript.RunContext|RunContext` ingesteld op `Enum.RunContext.Client`).
Als het onderdeel eigendom is van een client via **automatische** eigendom, kan deze functie worden aangeroepen vanuit zowel een clientscript **als** een serverscript; het aanroepen vanuit een clientscript voor een server-eigendom onderdeel heeft geen effect.


BasePart:ApplyImpulse

Een lineaire impuls vector die op de assemblage moet worden toegepast.


Pas een impuls toe op de assemblage op het `Class.BasePart.AssemblyCenterOfMass|centrum van massa` van de assemblage.


Deze functie past een instantane krachtimpuls toe op de assemblage van dit onderdeel, op de opgegeven positie in wereldruimte.

Als de positie niet op het `Class.BasePart.AssemblyCenterOfMass|centrum van massa` van de assemblage ligt, zal de impuls een positionele en roterende beweging veroorzaken.

De resulterende snelheid van de impuls is afhankelijk van de `Class.BasePart.AssemblyMass|massa` van de assemblage. Dus een hogere impuls is nodig om zwaardere assemblages te verplaatsen. Impulsen zijn nuttig voor gevallen waarin ontwikkelaars een kracht onmiddellijk willen toepassen, zoals een explosie of botsing.

Als het onderdeel [eigendom](/physics/network-ownership) is van de server, moet deze functie worden aangeroepen vanuit een server `Class.Script` (niet vanuit een `Class.LocalScript` of een `Class.Script` met
`Class.BaseScript.RunContext|RunContext` ingesteld op `Enum.RunContext.Client`).
Als het onderdeel eigendom is van een client via **automatische** eigendom, kan deze functie worden aangeroepen vanuit zowel een clientscript **als** een serverscript; het aanroepen vanuit een clientscript voor een server-eigendom onderdeel heeft geen effect.


BasePart:ApplyImpulseAtPosition

Een impuls vector die op de assemblage moet worden toegepast.


position

De positie, in wereldruimte, waar de impuls moet worden toegepast.


Pas een impuls toe op de assemblage op een specifieke positie.


Abonneert `callback` op de contactgegevens die de fysica-engine genereert voor dit onderdeel tijdens het detecteren van botsingen. Een keer per frame, nadat de simulatie is gestapt, ontvangt `callback` een array van samenvattingen die elke contactpatch beschrijven waarbij dit onderdeel betrokken was tijdens dat frame. Elke samenvatting rapporteert waar het contact plaatsvond, welke richting het opging, en hoe snel de twee onderdelen ten opzichte van elkaar bewogen op dat moment.

Deze methode is een apart mechanisme van `Class.BasePart.Touched`.

Geeft een foutmelding als `callback` `nil` is, of als het onderdeel geen afstammeling is van `Class.Workspace`.

#### Samenvattingsvelden

Elke invoer in de array die aan `callback` wordt doorgegeven, is een tabel met de volgende sleutels:

<table size="small">
<thead>
  <tr>
    <th>Sleutel</th>
    <th>Type</th>
    <th>Samenvatting</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><code>Tijd</code></td>
    <td><code>nummer</code></td>
    <td>Simulatietijd, in seconden, van de fysica substap die deze samenvatting heeft geproduceerd.</td>
  </tr>
  <tr>
    <td><code>Part0</code></td>
    <td><code>Class.BasePart</code></td>
    <td>Het geabonneerde onderdeel.</td>
  </tr>
  <tr>
    <td><code>Part1</code></td>
    <td><code>Class.BasePart</code></td>
    <td>Het andere onderdeel in het paar, dat <code>Class.Terrain</code> kan zijn.</td>
  </tr>
  <tr>
    <td><code>Punt</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Contactpunt in wereldruimte, gemiddeld over de punten in de patch.</td>
  </tr>
  <tr>
    <td><code>Normaal</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Eenheidscontactnormaal voor de patch, georiënteerd ten opzichte van het geabonneerde onderdeel.</td>
  </tr>
  <tr>
    <td><code>RelatieveSnelheid</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Snelheid van <code>Part1</code> ten opzichte van <code>Part0</code> op het contactpunt.</td>
  </tr>
  <tr>
    <td><code>Oppervlakte</code></td>
    <td><code>nummer</code></td>
    <td>Geschatte oppervlakte van de contactpatch, in vierkante studs. <code>0</code> voor een patch van minder dan drie punten, zoals een rand of hoekcontact.</td>
  </tr>
</tbody>
</table>

`Normaal` is georiënteerd ten opzichte van het geabonneerde onderdeel in plaats van ten opzichte van welk onderdeel de engine toevallig als eerste opsomde, dus als beide onderdelen van een paar zijn geabonneerd, ontvangt elke abonnement zijn eigen samenvatting met zichzelf als `Part0` en de normaal omgekeerd om overeen te komen.

`RelatieveSnelheid` is de snelheid van `Part1` ten opzichte van `Part0`, dus de grootte van de projectie op `Normaal` is de snelheid waarmee de twee onderdelen recht op elkaar afkomen of zich van elkaar verwijderen, en de component die tangentiëel is aan `Normaal` beschrijft glijdend en glijdend contact.

#### Rapportagegedrag

- Contactregistratie is alleen ingeschakeld zolang er ten minste één abonnement bestaat
  ergens in de `Class.Workspace`, en de kosten ervan schalen met het aantal geabonneerde onderdelen in plaats van met het totale aantal
  botsingen in de scène.
- Contacten tussen meerdere slapende onderdelen produceren geen samenvattingen.
- Contacten van onderdelen met `Class.BasePart.CanCollide` ingesteld op `false` produceren geen samenvattingen.
- Fysica kan verschillende substappen per frame uitvoeren, dus een paar dat in contact blijft over verschillende substappen produceert tot één samenvatting per patch per substap, allemaal geleverd in dezelfde aanroep van `callback`. Gebruik `Tijd`
  om ze te ordenen.
- Niet-convexe botsingsgeometrie produceert één samenvatting per paar van aangrenzende
  convexe hulls, en contact met `Class.Terrain` wordt verder gesplitst door
  contactnormaal, zodat een van beide verschillende samenvattingen voor hetzelfde paar kan opleveren
  binnen één substap.
- Niets wordt gerepliceerd. Elke client genereert samenvattingen voor de
  botsingen die hij bezit. Zie
  [netwerk eigendom](/physics/network-ownership).
- Het vernietigen van het onderdeel verbreekt zijn abonnementen.


BasePart:BindToCollisionSummaries

callback

Wordt aangeroepen met een array van samenvattingstabellen, maximaal één keer per frame, als
toestand het onderdeel betrokken was bij een botsing.


Een `Datatype.RBXScriptConnection` die de abonnement beëindigt wanneer deze wordt losgekoppeld.


Abonneert zich op gedetailleerde per-frame contactgegevens voor de botsingen waarbij dit onderdeel betrokken is.


Breekt elke oppervlakteverbinding met een aangrenzend onderdeel, inclusief
`Class.Weld` en andere `Class.JointInstance`.


BasePart:BreakJoints

BasePart:breakJoints

Geeft terug of de onderdelen met elkaar kunnen botsen of niet. Deze
functie houdt rekening met de botsingsgroepen van de twee onderdelen. Deze
functie zal een foutmelding geven als het opgegeven onderdeel geen BasePart is.


BasePart:CanCollideWith

Het opgegeven onderdeel dat wordt gecontroleerd op botsbaarheid.


Of de onderdelen met elkaar kunnen botsen.


Geeft terug of de onderdelen met elkaar kunnen botsen.


Dit voorbeeld controleert of het netwerkbezit van de eerste
`BasePart` genaamd _Part_ in de `Workspace` kan worden ingesteld.


De CanSetNetworkOwnership-functie controleert of je het netwerk eigendom van een onderdeel kunt instellen.

De retourwaarde van de functie verifieert of je `Class.BasePart:SetNetworkOwner()` of
`Class.BasePart:SetNetworkOwnershipAuto()` kunt aanroepen zonder een foutmelding te krijgen.
Het retourneert true als je het netwerk eigendom kunt wijzigen/lezen, of retourneert false en de reden waarom je dat niet kunt, als een string.


BasePart:CanSetNetworkOwnership

Of je het netwerk eigendom kunt wijzigen of lezen en de reden.


Controleert of je het netwerk eigendom van een onderdeel kunt instellen.


Geeft het dichtstbijzijnde punt op het oppervlak van het onderdeel terug naar de opgegeven wereldruimte
positie. Als de opgegeven positie zich binnen het onderdeel bevindt, wordt deze
zoals deze is geretourneerd.

Voor `Class.MeshPart` en `Class.PartOperation` instanties respecteert deze methode
de `Enum.CollisionFidelity` waarde van het onderdeel. Retourwaarden kunnen
verschillen afhankelijk van of de mesh wordt behandeld als een doos, een hull, of een
complexere vorm.


BasePart:GetClosestPointOnSurface

Het wereldruimte punt waarvoor het dichtstbijzijnde oppervlakpunt moet worden gevonden.


Het dichtstbijzijnde punt op het oppervlak van het onderdeel in wereldruimte.


Geeft het dichtstbijzijnde punt op het oppervlak van het onderdeel terug naar het opgegeven punt.


Geeft een tabel terug van onderdelen die met het object zijn verbonden door een soort rigide
verbinding.

Als `recursive` waar is, zal deze functie alle onderdelen in de
assemblage die rigide verbonden zijn met de BasePart retourneren.

#### Rigide Verbindingen

Wanneer een verbinding twee onderdelen met elkaar verbindt `(Part0 → Part1)`, is een verbinding **rigide** als de fysica van `Part1` volledig is vergrendeld door `Part0`.
Dit geldt alleen voor de volgende verbindingstypen:

- `Class.Weld`
- `Class.Snap`
- `Class.ManualWeld`
- `Class.Motor`
- `Class.Motor6D`
- `Class.WeldConstraint`


BasePart:GetConnectedParts

recursive

Een tabel van onderdelen die met het object zijn verbonden door een soort
`Class.JointInstance|verbinding`.


Een array van `Class.BasePart|BaseParts` die met dit onderdeel zijn verbonden door rigide
verbindingen. Als `recursive` waar is, omvat het alle onderdelen in de assemblage.


Geeft een tabel terug van onderdelen die met het object zijn verbonden door een soort rigide
verbinding.


Geeft een array terug van alle `Class.JointInstance|Joints` en
`Class.Constraint|Constraints` die met dit onderdeel zijn verbonden en actief zijn in
de simulatie.

Een joint of constraint wordt alleen actief zodra beide onderdelen die het
verbinden zich binnen dezelfde gesimuleerde container bevinden, zoals
`Class.Workspace` of een `Class.WorldModel`. Als een van de verbonden onderdelen
buiten die container is — bijvoorbeeld, geparent aan
`Class.ServerStorage`, of in een andere `Class.WorldModel` — wordt de joint
niet geactiveerd. **GetJoints()** omvat die joint niet op een van beide onderdelen,
ook al bestaat de joint-instantie nog steeds in het datamodel.


BasePart:GetJoints

Een array van alle `Class.JointInstance|Joints` en
`Class.Constraint|Constraints` die met het onderdeel zijn verbonden en actief zijn
in de simulatie.


Geeft alle Joints of Constraints terug die met dit onderdeel zijn verbonden en actief zijn
in de simulatie.


Dit voorbeeld maakt een nieuw onderdeel, myPart, in de Workspace van het spel, met
afmetingen 4x6x4 studs. Het onderdeel is ook verankerd.

Vervolgens wordt myMass ingesteld op de massa van het nieuwe onderdeel. De massa van het onderdeel wordt
afgedrukt aan het einde van de print-instructie:

> De massa van mijn onderdeel is ...


**GetMass** geeft de waarde van de alleen-lezen `Class.BasePart.Mass|Mass`
eigenschap terug.

Deze functie is ouder dan de Mass-eigenschap. Het blijft ondersteund voor
achterwaartse compatibiliteit; je moet de Mass-eigenschap direct gebruiken.


BasePart:GetMass

Geeft de waarde van de `Class.BasePart.Mass|Mass` eigenschap terug.


BasePart:getMass

Geeft de huidige speler terug die de netwerk eigenaar van dit onderdeel is, of `nil`
in het geval van de server.


BasePart:GetNetworkOwner

De huidige speler die de netwerk eigenaar van dit onderdeel is, of `nil` in
het geval van de server.


Geeft true terug als de game-engine automatisch de netwerk eigenaar voor dit onderdeel beslist.


BasePart:GetNetworkOwnershipAuto

Of de game-engine automatisch de netwerk eigenaar voor dit onderdeel beslist.


Geeft de ingeschakelde `Class.NoCollisionConstraint` objecten terug die momenteel
zijn geregistreerd voor dit onderdeel in zijn fysica-wereld. Een
`Class.NoCollisionConstraint` schakelt botsingen uit tussen de twee specifieke
onderdelen waarnaar het verwijst, terwijl elk van die onderdelen nog steeds met de
rest van de wereld kan botsen.

De geretourneerde array is leeg als er momenteel geen dergelijke beperking is geregistreerd
voor dit onderdeel. De volgorde van de geretourneerde beperkingen is niet gegarandeerd.


BasePart:GetNoCollisionConstraints

Een array van de ingeschakelde `Class.NoCollisionConstraint` objecten
momenteel geregistreerd voor dit onderdeel in zijn fysica-wereld.


Geeft de ingeschakelde `Class.NoCollisionConstraint` objecten terug die momenteel
zijn geregistreerd voor dit onderdeel in zijn fysica-wereld.


Deze functie was relevant toen de lag-compensatie-interpolatie van onderdelen online intern was. De interpolatie wordt nu
toegepast op de `Datatype.CFrame` direct.


BasePart:GetRenderCFrame

De `Datatype.CFrame` die vertegenwoordigt waar het onderdeel wordt gerenderd,
wat nu gelijk is aan de `Class.BasePart.CFrame|CFrame` van het onderdeel.


OBSOLETE. Geeft een CFrame terug die beschrijft waar het onderdeel wordt gerenderd.


Geeft het basis onderdeel van een assemblage terug. Bij het verplaatsen van een assemblage van onderdelen
met behulp van een `Datatype.CFrame`. is het belangrijk om dit basis onderdeel te verplaatsen (dit
zal alle andere onderdelen die eraan zijn verbonden dienovereenkomstig verplaatsen). Meer informatie
is beschikbaar in het [Assemblies](/physics/assemblies) artikel.

Deze functie is ouder dan de
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` eigenschap. Het blijft
ondersteund voor achterwaartse compatibiliteit, maar je moet de
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` direct gebruiken.


BasePart:GetRootPart

Het basis onderdeel van een assemblage (een verzameling van onderdelen die met elkaar zijn verbonden).


Geeft het basis onderdeel van een assemblage van onderdelen terug.


Geeft een tabel terug van alle onderdelen die fysiek interageren met dit
onderdeel. Als het onderdeel zelf CanCollide op false heeft staan, retourneert deze functie
een lege tabel, tenzij het onderdeel een
`Class.TouchTransmitter|TouchInterest` object heeft dat eraan is geparent (wat betekent
dat er iets is verbonden met de Touched gebeurtenis). Onderdelen die aangrenzend zijn maar
niet intersecteren worden niet als aanrakend beschouwd. Deze functie is ouder dan de
`Class.WorldRoot:GetPartsInPart()` functie, die meer
flexibiliteit biedt en de speciale `Class.TouchTransmitter|TouchInterest`
regels die hierboven zijn beschreven, vermijdt. Gebruik in plaats daarvan `Class.WorldRoot:GetPartsInPart()`.


BasePart:GetTouchingParts

Een tabel van alle onderdelen die intersecteren en met dit onderdeel kunnen botsen.


Geeft een tabel terug van alle `Class.BasePart.CanCollide` true onderdelen die
intersecteren met dit onderdeel.


Geeft de lineaire snelheid van de assemblage van het onderdeel op de gegeven positie
terwijl het zich ten opzichte van dit onderdeel bevindt. Het kan worden gebruikt om de lineaire snelheid van
onderdelen in een assemblage te identificeren, anders dan het root onderdeel. Als de assemblage geen
hoeksnelheid heeft, zal de lineaire snelheid altijd hetzelfde zijn voor
every positie.


BasePart:GetVelocityAtPosition

De wereldruimte positie waarop de lineaire snelheid van de assemblage moet worden berekend.


Een `Datatype.Vector3` die de lineaire snelheid van de assemblage
op de opgegeven wereldruimte positie vertegenwoordigt.


Geeft de lineaire snelheid van de assemblage van het onderdeel op de gegeven positie
ten opzichte van dit onderdeel terug.


Maakt een nieuwe `Class.IntersectOperation` aan van de intersecterende geometrie van
toepassing en de andere onderdelen in de gegeven array. Alleen `Class.Part|Parts`
worden ondersteund, niet `Class.Terrain` of `Class.MeshPart|MeshParts`. Vergelijkbaar met `Class.Instance:Clone()|Clone()`, heeft het geretourneerde object geen set
`Class.Instance.Parent|Parent`.

De volgende eigenschappen van het oproepende onderdeel worden toegepast op de
resulterende `Class.IntersectOperation`:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

#### Migratie

Het wordt ten zeerste aanbevolen om de nieuwere
`Class.GeometryService:IntersectAsync()` in plaats van deze methode te gebruiken. Naast betere prestaties en meer functies, verschilt de nieuwe methode als volgt:

- De output is een array van instanties in plaats van een enkele instantie.
- De invoeronderdelen hoeven niet aan de scène te zijn geparent, waardoor achtergrondbewerkingen mogelijk zijn.
- Wanneer de `SplitApart` optie is ingesteld op `true` (standaard), wordt elk afzonderlijk
  lichaam in zijn eigen `Class.PartOperation` geretourneerd.
- Alle geretourneerde onderdelen bevinden zich in de coördinatenruimte van het hoofdonderdeel, zodat
  hun `Class.PVInstance.Origin` posities hetzelfde zijn als die van het hoofdonderdeel. Dit houdt de vertices van de mesh in dezelfde positie
  ten opzichte van het object als voor de bewerking, maar het betekent ook dat
  de `(0, 0, 0)` van een geretourneerd onderdeel niet noodzakelijkerwijs in het midden van
  zijn lichaam is.

#### Opmerkingen

- De oorspronkelijke onderdelen blijven intact na een succesvolle intersect
  operatie. In de meeste gevallen moet je `Class.Instance.Destroy|Destroy()`
  alle oorspronkelijke onderdelen en het geretourneerde
  `Class.IntersectOperation` naar dezelfde plaats als het oproepende
  `Class.BasePart`.
- Standaard worden de gezichtskleuren van de resulterende intersectie geleend
  van de `Class.BasePart.Color|Color` eigenschap van de oorspronkelijke onderdelen. Om
  de hele intersectie naar een specifieke kleur te veranderen, stel je de
  `Class.PartOperation.UsePartColor|UsePartColor` eigenschap in op `true`.
- Als een intersectieoperatie zou resulteren in een onderdeel met meer dan 20.000
  driehoeken, wordt deze vereenvoudigd tot 20.000 driehoeken.


BasePart:IntersectAsync

parts

De objecten die deelnemen aan de intersectie.


collisionfidelity

De `Enum.CollisionFidelity` waarde voor de resulterende
`Class.IntersectOperation`.


renderFidelity

De `Enum.RenderFidelity` waarde van de resulterende
`Class.PartOperation`.


Resulterende `Class.IntersectOperation` met de standaardnaam **Intersect**.


Maakt een nieuwe `Class.IntersectOperation` aan van de overlappende geometrie van
toepassing en de andere onderdelen in de gegeven array.


Geeft true terug als het object is verbonden met een onderdeel dat het op zijn plaats houdt (bijv. een `Class.BasePart.Anchored|Anchored` onderdeel), anders retourneert het false. In een assemblage die een `Class.BasePart.Anchored|Anchored` onderdeel heeft, is elk ander onderdeel verankerd.


BasePart:IsGrounded

Of het object is verbonden met een onderdeel dat het op zijn plaats houdt.


Geeft true terug als het object is verbonden met een onderdeel dat het op zijn plaats houdt (bijv. een `Class.BasePart.Anchored|Anchored` onderdeel), anders retourneert het false.


Maakt een verbinding aan op elke zijde van de `Class.BasePart|Part` die een
`Enum.SurfaceType` heeft die een verbinding kan maken, het zal een verbinding maken met alle aangrenzende onderdelen.

Verbinden worden gemaakt tussen de zijden en alle vlakke aangrenzende oppervlakken,
afhankelijk van de oppervlakken van de zijden.

- Gladde oppervlakken zullen geen verbindingen maken
- Lijmoppervlakken zullen een `Class.Glue` verbinding maken
- Lasverbinding zal een `Class.Weld` verbinding maken met elk oppervlak, behalve voor
  Unjoinable
- Studs, Inlet, of Universeel zullen elk een `Class.Snap` verbinding maken met
  een van de andere twee oppervlakken (bijv. Studs met Inlet en
  Universeel)
- Scharnier- en motoroppervlakken creëren `Class.Rotate` en `Class.RotateV` verbinding
  instanties

In tegenstelling tot `Class.Model:MakeJoints()`, vereist deze functie een array van
onderdelen als parameter. Deze array wordt als volgt gegeven:

```
part:MakeJoints({part1, part2, part3})
```
Verbinden worden gebroken als er voldoende kracht op wordt uitgeoefend door een
`Class.Explosion`, tenzij een `Class.ForceField` object is geparent aan de
`Class.BasePart` of voorouder `Class.Model`. Om deze reden worden ze vaak gebruikt om eenvoudige vernietigbare gebouwen en andere modellen te maken.


BasePart:MakeJoints

Maakt een verbinding aan op elke zijde van het object die een oppervlakte-ID heeft die een verbinding kan maken.


BasePart:makeJoints

Verandert de grootte van een object net zoals het gebruik van de Studio resize-tool.


BasePart:Resize

normalId

deltaAmount

Hoeveel te groeien/krimpen aan de opgegeven zijde.


BasePart:resize

Stelt de opgegeven speler in als netwerk eigenaar voor dit en alle verbonden onderdelen.
Wanneer playerInstance `nil` is, zal de server de eigenaar zijn in plaats van een
speler.


BasePart:SetNetworkOwner

playerInstance

De speler die netwerk eigendom van het onderdeel krijgt.


Stelt de opgegeven speler in als netwerk eigenaar voor dit en alle verbonden onderdelen.


Laat de game-engine dynamisch beslissen wie de fysica van het onderdeel zal afhandelen
(een van de clients of de server).


BasePart:SetNetworkOwnershipAuto

Maakt een nieuwe `Class.UnionOperation` aan van het onderdeel, minus de geometrie
bezet door de onderdelen in de gegeven array. Alleen `Class.Part|Parts` zijn
ondersteund, niet `Class.Terrain` of `Class.MeshPart|MeshParts`. Vergelijkbaar met
`Class.Instance:Clone()|Clone()`, heeft het geretourneerde object geen set
`Class.Instance.Parent|Parent`.

Let op dat de resulterende unie niet leeg kan zijn door aftrekken. Als de
bewerking zou resulteren in volledig lege geometrie, zal deze mislukken.

#### Migratie

Het wordt ten zeerste aanbevolen om de nieuwere
`Class.GeometryService:SubtractAsync()` in plaats van deze methode te gebruiken. Naast betere prestaties en meer functies, verschilt de nieuwe methode als volgt:

- De output is een array van instanties in plaats van een enkele instantie.
- De invoeronderdelen hoeven niet aan de scène te zijn geparent, waardoor achtergrondbewerkingen mogelijk zijn.
- Wanneer de `SplitApart` optie is ingesteld op `true` (standaard), wordt elk afzonderlijk
  lichaam in zijn eigen `Class.PartOperation` geretourneerd.
- Alle geretourneerde onderdelen bevinden zich in de coördinatenruimte van het hoofdonderdeel, zodat
  hun `Class.PVInstance.Origin` posities hetzelfde zijn als die van het hoofdonderdeel. Dit houdt de vertices van de mesh in dezelfde positie
  ten opzichte van het object als voor de bewerking, maar het betekent ook dat
  de `(0, 0, 0)` van een geretourneerd onderdeel niet noodzakelijkerwijs in het midden van
  zijn lichaam is.


BasePart:SubtractAsync

De objecten die deelnemen aan de aftrekking.


De `Enum.CollisionFidelity` waarde voor de resulterende
`Class.UnionOperation`.


Resulterende `Class.UnionOperation` met de standaardnaam **Union**.


Maakt een nieuwe `Class.UnionOperation` aan van het onderdeel, minus de geometrie
bezet door de onderdelen in de gegeven array.


Toont `Class.BasePart:TorqueToAngularAcceleration()` aan.


Geeft de wereldruimte hoeksversnelling terug die zou resulteren uit
het toepassen van het opgegeven koppel op de assemblage van het onderdeel, met optionele rekening houdend
met gyroscopische effecten.

Dit is de inverse van `Class.BasePart:AngularAccelerationToTorque()`. Het
is nuttig voor het voorspellen hoe een assemblage zal reageren op een toegepast
koppel.

De berekening gebruikt:

**α = I⁻¹ · (τ − ω × (I · ω))**

waarbij **I** de wereldruimte inertietensor van de assemblage is, **τ** het
toegepaste koppel is, en **ω** de hoeksnelheid is.

Als het onderdeel geen afstammeling is van `Class.Workspace`, retourneert het `(0, 0, 0)`.
Als de assemblage is verankerd, retourneert het `(0, 0, 0)`.

#### Gyroscopische Effecten

Wanneer een draaiende assemblage een asymmetrische inertietensor heeft, hangt de
versnelling die resulteert uit een toegepast koppel ook af van de huidige
hoeksnelheid. De `angVelocity` parameter houdt rekening met deze
gyroscopische effecten. Als weggelaten (standaard op nul), negeert het resultaat
bijdrage van dit resultaat.


BasePart:TorqueToAngularAcceleration

torque

De koppelvector die op de assemblage in wereldruimte is toegepast.


De huidige hoeksnelheid van de assemblage in wereldruimte. Standaard
is dit `(0, 0, 0)`. Geef de hoeksnelheid van de assemblage op om rekening te houden met
gyroscopische effecten.


Geeft de hoeksversnelling terug die zou resulteren uit het toepassen van een gegeven
koppel op de assemblage van dit onderdeel, met optionele rekening houdend met gyroscopische
effecten.


BasePart

De abstracte basis klasse voor objecten in de wereld die fysiek interageren.


/reference/engine/classes/SkateboardPlatform.yaml