Przejdź do treści
Biblioteka skilli
Programowanie · Nauka i wyjaśnianie

unity-core

/unity-core

Wyjaśnia podstawy skryptowania Unity: cykl życia MonoBehaviour, model GameObject i Component, ScriptableObjects, prefaby, serializacja, coroutines, zdarzenia i kolejność wykonania.

Licencja
MIT
Ostatnia zmiana repozytorium
21.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 21.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wyjaśnia podstawy skryptowania Unity: cykl życia MonoBehaviour, model GameObject i Component, ScriptableObjects, prefaby, serializacja, coroutines, zdarzenia i kolejność wykonania.

Oryginalny opis (EN)

Unity core scripting fundamentals — MonoBehaviour lifecycle, GameObject / Component model, ScriptableObjects, prefabs, serialization, coroutines, events, and execution order. USE WHEN: writing or refactoring core Unity scripts, designing data flow, setting up ScriptableObjects, dealing with serialization issues, choosing between Update / FixedUpdate / LateUpdate, coroutine vs async patterns. DO NOT USE FOR: rendering / shaders (use `unity-rendering`); 2D-specific topics (use `unity-2d-*`); networking (use `unity-netcode`); ECS/DOTS (use `unity-dots`).

Jak działa

  1. MonoBehaviour Lifecycle
  2. ScriptableObject — data assets
  3. Reference injection (no Find)
  4. Coroutines vs async
  5. Events — UnityEvent vs C event vs ScriptableObject channel
  6. Serialization rules
  7. Anti-patterns
  8. Production checklist
Sekcje z nagłówków SKILL.md, w oryginale · 111 linii, 601 słów
Podgląd SKILL.md
---
name: unity-core
description: |
  Unity core scripting fundamentals — MonoBehaviour lifecycle, GameObject /
  Component model, ScriptableObjects, prefabs, serialization, coroutines,
  events, and execution order.

  USE WHEN: writing or refactoring core Unity scripts, designing data flow,
  setting up ScriptableObjects, dealing with serialization issues, choosing
  between Update / FixedUpdate / LateUpdate, coroutine vs async patterns.

  DO NOT USE FOR: rendering / shaders (use `unity-rendering`); 2D-specific
  topics (use `unity-2d-*`); networking (use `unity-netcode`); ECS/DOTS
  (use `unity-dots`).
allowed-tools: Read, Grep, Glob, Write, Edit
---

# Unity Core

## MonoBehaviour Lifecycle

```
Awake          → once, per script instance, even if disabled
OnEnable       → each time GameObject/component becomes active
Start          → once, just before first Update, only if active
FixedUpdate    → fixed timestep (default 0.02s); physics writes here
Update         → every frame
LateUpdate     → after all Update; camera follow, IK adjustments
OnDisable      → when component/GO becomes inactive
OnDestroy      → when component/GO is destroyed (or app quits)
```

Order across objects: `Awake`/`OnEnable` for ALL objects, then `Start` for ALL, then per-frame loops. Tweak per-script via Edit > Project Settings > Script Execution Order — sparingly.

## ScriptableObject — data assets

```csharp
[CreateAssetMenu(menuName = "Game/Weapon", fileName = "NewWeapon")]
public class WeaponData : ScriptableObject {
    public string displayName;
    [Min(0)] public int damage = 10;
    [Range(0f, 5f)] public float fireRate = 0.5f;
    public Sprite icon;
    public AudioClip fireSfx;
}
```

Use them for: tuning data, configurable enemy stats, level definitions, event channels. Avoid them as runtime mutable singletons across scenes — values persist in editor between play sessions.

## Reference injection (no Find)

```csharp
public class Enemy : MonoBehaviour {
    [SerializeField] private WeaponData weapon;     // assigned in inspector
    [SerializeField] private Transform target;       // explicit dependency

    private Rigidbody _rb;                           // cached own component
    private void Awake() => _rb = GetComponent<Rigidbody>();
}
```

Never: `GameObject.Find`, `FindObjectOfType` in Update. Acceptable: once in Awake/Start when injection isn't possible (rare).

## Coroutines vs async

| Use case | Pick |
|----------|------|
| Wait one frame / WaitForSeconds / WaitForFixedUpdate | Coroutine — `IEnumerator` + `yield return` |
| HTTP / file IO / long async ops | `async UniTask` (UniTask package) or `async Task` with `WhenAll` |
| Cancellation / structured concurrency | UniTask + CancellationToken |
| Cross-platform WebGL | Coroutines (no real threads) or UniTask |

```csharp
private Coroutine _flashRoutine;
private IEnumerator FlashRoutine() {
    var renderer = GetComponent<Renderer>();
    var original = renderer.material.color;
    for (int i = 0; i < 3; i++) {
        renderer.material.color = Color.red;
        yield return new WaitForSeconds(0.1f);
        renderer.material.color = original;
        yield return new WaitForSeconds(0.1f);
    }
    _flashRoutine = null;
}

public void Flash() {
    if (_flashRoutine != null) StopCoroutine(_flashRoutine);
    _flashRoutine = StartCoroutine(FlashRoutine());
}
```

## Events — UnityEvent vs C# event vs ScriptableObject channel

| Style | When |
|-------|------|
| `C# event Action<T>` | Internal cross-script communication, no inspector wiring |
| `UnityEvent<T>` | Inspector-bound callbacks; designer-friendly |
| ScriptableObject event channel | Decoupling across scenes / between systems with no direct reference |

## Serialization rules

- `[SerializeField] private` over `public` for inspector exposure.
- Lists/arrays of references serialize fine; cyclic references via `[SerializeReference]` only when needed (heavier).
- `Dictionary<TK,TV>` does NOT serialize — use parallel `List<TK>`+`List<TV>` or `SerializableDictionary` packages.
- For polymorphic data (e.g. behaviour trees), use `[SerializeReference]` + interfaces.

## Anti-patterns

| Anti-pattern | Fix |
|---|---|
| Logic on every Update | Throttle with `if (Time.frameCount % N == 0)` or events |
| `Camera.main` in Update | Cache once in Awake (`_mainCam = Camera.main;`) |
| `transform.position` writes inside FixedUpdate without Rigidbody | Use `rb.MovePosition`, never `transform.position` for physics objects |
| Singleton MonoBehaviour with `Instance` accessed before Awake | Move init to `Awake`; use `RuntimeInitializeOnLoadMethod` for boot logic |
| Public mutable fields | `[SerializeField] private` + property |

## Production checklist

- [ ] Asmdefs split runtime / editor / test
- [ ] No `Find*` calls in hot paths
- [ ] All physics writes in FixedUpdate
- [ ] ScriptableObjects used for tuning data
- [ ] String hashes cached for Animator parameters
- [ ] Events disposed in OnDisable / OnDestroy
- [ ] Coroutines stopped on disable to avoid orphan loops

Wersje

W bazie nie ma innych skilli o nazwie unity-core.

Migawka bazy z 13.11.2026 · wersja paczki 16e05213693a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100unity-csharp-scripting
    Pisze skrypty C# rozgrywki w Unity 6.3 LTS: cykl życia MonoBehaviour, dostęp do GameObject i komponentów, coroutines i serializacja w Inspectorze.
  • 100unity-csharp-scripting
    Pisze skrypty gameplayu w C# dla Unity 6.3: cykl życia MonoBehaviour, dostęp do komponentów, korutyny i serializację pól.
  • 100unity-scripting
    Opisuje skryptowanie w C# w Unity 6: skrypty MonoBehaviour, zdarzenia cyklu życia, korutyny, async/await z Awaitable, ScriptableObjecty, delegaty i podstawowe API jak Vector3 czy Time.
  • 100unity
    Pomaga pisać, recenzować i organizować kod gry Unity w C# dla Unity 6 LTS: GameObjects, MonoBehaviour, prefaby, ScriptableObjects, sceny, Input System, coroutines i Awaitable, Addressables i ustawienia buildu.
  • 100unity-foundations
    Wyjaśnia podstawy architektury Unity 6: GameObjecty, komponenty, sceny, prefaby, ScriptableObjecty, tagi, warstwy i konwencje struktury projektu, na podstawie dokumentacji 6.3 LTS.
  • 100unity-dots
    Obsługuje Unity DOTS: Entities 1.x, joby kompilowane Burst, IJobChunk i IJobEntity, NativeArray, SystemBase i ISystem, baking GameObject na encje oraz komponenty hybrydowe.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.