Documentatie

EEffectType

namespace FX.Enumeration

public enum EEffectType

Enumerators

Particle, // Een effect gebaseerd op particles, zoals vonken of rook
Audio     // Een geluidseffect, zoals een explosie of klikgeluid

ETiming

namespace FX.Enumeration

public enum ETiming

Enumerators

StartWithPrevious, // Start tegelijkertijd met het vorige effect
StartAfterPrevious // Start nadat het vorige effect is afgelopen

Effect

namespace FX

public class Effect

Fields

// Het moment waarop het effect moet starten (tegelijk of na een ander)
public ETiming timing;

// Het type effect (particle of audio)
public EEffectType effectType;

// De ParticleSystem die afgespeeld wordt bij dit effect
public ParticleSystem particleSystem;

// Het audiobestand dat afgespeeld wordt bij een audio-effect
public AudioClip audioClip;

// De AudioSource die het audiobestand afspeelt
public AudioSource audioSource;

// Tijd (in seconden) voordat het effect gestart wordt
[SerializeField] private float delay;

// Wordt aangeroepen wanneer het effect begint
public UnityEvent onEffectStart;

// Wordt aangeroepen wanneer het effect eindigt
public UnityEvent onEffectEnd;

// Timer die de vertraging voor het starten van het effect regelt
private CountdownTimer _delayTimer;

// Timer die de totale duur van het effect bijhoudt
private CountdownTimer _timer;

Properties

// Geeft de lengte (duur) van het effect terug op basis van het type
public float Length { get; }

Methods

// Initialiseert de timers en voegt events toe
public void Initialize();

// Start het effect met vertraging
public void Play();

// Stopt het effect direct, afhankelijk van het type
public void Stop();

// Wordt aangeroepen wanneer de delay-timer eindigt, en speelt het effect af
private void PlayEffect();

FXSystem

namespace FX

public class FXSystem : MonoBehaviour

Fields

// De lijst van effecten die dit systeem beheert
[SerializeField] private List<Effect> effects;

// Speel automatisch bij het starten van het spelobject
[SerializeField] private bool playOnStart;

Methods

// Speelt het volgende batch van effecten af
public void Play();

// Stopt alle actieve effecten
public void Stop();

GameData

namespace Multiplayer

public class GameData : NetworkBehaviour

Fields

// Singleton-instantie van GameData
public static GameData instance;

// De speler-ID van de speler die momenteel aan de beurt is
public NetworkVariable<ulong> currentPlayerTurn = new();

Methods

// Wordt aangeroepen wanneer dit object gespawned wordt via Netcode
public override void OnNetworkSpawn();

// Zet de speler die als eerste aan de beurt is (alleen op de server)
private void InitializePlayerTurn();

// Wisselt naar de volgende speler in de lijst (alleen via server RPC)
[Rpc(SendTo.Server)]
public void SwitchPlayerTurnRpc();

PlayerInputHandler

namespace (global namespace)

public class PlayerInputHandler : NetworkBehaviour

Methods

// Wordt aangeroepen bij het voltooien van het laden van een scène (alleen voor de eigenaar)
[Rpc(SendTo.Owner)]
private void OnLoadCompletedRpc(ulong _clientId, string _sceneName, LoadSceneMode _loadSceneMode);

// Coroutine die de input van de speler na één frame inschakelt
private IEnumerator EnablePlayerInput(PlayerInput _playerInput);

GridCell

namespace PlayerGrid

public class GridCell

Constructors

// Constructor die de positie en wereldpositie van de cel instelt
public GridCell(Vector2Int _position, Vector3 _worldPosition);

Fields

// De cell-positie binnen het grid (in grid-coördinaten)
public Vector2Int position;

// De wereldpositie van deze gridcel
public Vector3 worldPosition;

// Of deze cel al bezet is door een schip
public bool isTaken;

GridHandler

namespace PlayerGrid

public class GridHandler : NetworkBehaviour

Fields

// De singleton-instantie van GridHandler
public static GridHandler instance

// De DashboardHandler voor het beheren van UI
[SerializeField] private DashboardHandler _dashboardHandler;

// GameData voor het regelen van game events
[SerializeField] private GameData gameData;

// De grote van het grid (breedte en hoogte)
public const byte gridSize; // const waarde: 10

// Het maximaal aantal schepen die geplaatst mogen worden
private const byte _maxShips; // const waarde: 5

// Het maximaal aantal mijnen die geplaatst mogen worden
private const byte _maxMines; // const waarde: 2

// Het grid van cellen
private GridCell[,] _grid;

// De cell waar de muis op staat
private GridCell _current;

// Een lijst van alle schepen op het grid
private UniqueList<ShipBehaviour> _ships = new UniqueList<ShipBehaviour>();

// De lagen waar het grid zich op bevindt
[SerializeField] private LayerMask interactionLayers;

Properties

// Een event dat wordt aangeroepen wanneer het schip moet controlleren of de positie correct is
public UnityEvent<bool> OnValidate { get; private set; }

// Een event dat wordt aangeroepen wanneer de muis naar een nieuwe cell beweegt
public UnityEvent<Vector3> OnMove { get; private set; }

// Een event dat wordt aangeroepen wanneer de muis boven het grid hangt
public UnityEvent<bool> OnHover { get; private set; }

// Een event dat wordt aangeroepen om aan te geven of het grid af is
public UnityEvent<bool> OnIsReady { get; private set; }

// Een event dat wordt aangeroepen wanneer er wordt aangevallen door een raket
public UnityEvent<GridCell> OnAttacked { get; private set; }

// Een event dat wordt aangeroepen wanneer er een mijn wordt geplaatst
public UnityEvent<GridCell> OnMineSet { get; private set; }

// Het schip dat de juiste events aangeroepen krijgt wanneer hij geplaatst moet worden
public ShipBehaviour Ship { private get; set;}

Methods

// Zorg ervoor dat alle rotatie input wordt gebonden
private void InitializeInput();

// Creëer het grid met alle cellen
private void InitializeGrid();

// zet de cel waar de muis over hangt
private void MoveOnGrid();

// Is de positie waar het schip nu staat mogelijk
private bool IsValidPosition();

// Plaats het huidige schip op het grid
public void Place();

// Haal het gevraagde schip van het grid af
public void Clear(ShipBehaviour _requestedShip);

// Controlleer of de target cell een treffer of misser is
[Rpc(SendTo.NotMe)]
public void CheckTargetCellRpc(byte _targetCell);

// Is de cel op de positie geraakt
public bool Hit(Vector2Int _position);

// Mijn treffer of misser
public void MineCallback(Vector2Int _target, bool _hit);

// Plaats een mijn op de gegeven target op de andere speler
[Rpc(SendTo.NotMe)]
public void PlaceMineRpc(byte _targetCell);

// Zorg ervoor dat schepen niet meer verplaatst kunnen worden
public void LockGrid();

// Krijg het schip op de gegeven cel
public ShipBehaviour ShipFromCell(GridCell _cell);

// Krijg het schip op de gegeven positie op het grid
public ShipBehaviour ShipFromPosition(Vector2Int _position);

// Krijg de wereld positie van een grid positie
public Vector3 CellWorldPosition(Vector2Int _cellPosition);

// Mag er nog een mijn geplaatst worden
public bool MineAllowed();

GridShape

namespace PlayerGrid

[System.Serializable]
public class GridShape

Fields

// Alle cellen die samen deze vorm maken
public Vector2Int[] offsets;

Properties

// Krijg de index van de gegeven waarde
public int this[Vector2Int offset] { get; }

Methods

// Draai de vorm rechtsom
public void RotateClockwise();

// Draai de vorm linksom
public void RotateCounterClockwise();

// bevat de vorm deze cell
public bool ContainsOffset(Vector2Int _offset);

SceneLoader

namespace SceneManagement

public class SceneLoader : NetworkBehaviour

Fields

// De singleton-instantie van SceneLoader
public static SceneLoader instance;

// Laad de scene op start
public bool loadOnStart;

// De scene om te laden
public string sceneToLoad;

// Moet de scene op het netwerk geladen worden
public bool isNetworked;

// De scene om terug te laden als iets fout gaat
public string fallbackScene;

// De extra tijd die het duurt om te laden
public float loadDelay;

Methods

// Laad de scene op het netwerk of lokaal
public void LoadScene(string _sceneName, bool _isNetworked);

// Laad de scene op het netwerk of lokaal met een vertraging
public void LoadScene(string _sceneName, bool _isNetworked, float _loadDelay);

// Laad de scene lokaal direct
public void LoadScene(string _scene);

AttackerData

namespace ShipAttackers.Data

public struct AttackerData

Constructors

// Constructor die de posities instelt
public AttackerData(Vector2Int _gridPosition, Vector3 _startPosition);

Properties

// De positie van de attacker in grid-coördinaten
public Vector2Int GridPosition { get; private set; }

// De eind positie van de attacker in wereld-coördinaten
public Vector3 EndPosition { get; set; }

// De begin positie van de attacker in wereld-coördinaten
public Vector3 StartPosition { get; private set; }

MissileAttackHandler

namespace ShipAttackers.Missile

public class MissileAttackHandler : ShipAttackerHandler<MissileBehaviour>

MissileBehaviour

namespace ShipAttackers.Missile

public class MissileBehaviour : ShipAttacker

Fields

// De start positie van de raket
[SerializeField] private Vector3 startPosition;

// De afstand wanneer een treffer wordt geregristreerd
[SerializeField][Range(0f, 1f)] private float hitDistance;

// De boog van de raket
[SerializeField] private AnimationCurve heightCurve;

// De hoogte van de raket
[SerializeField] private float heightMultiplier;

// De snelheid van de raket
[SerializeField] private float speed;

Methods

// Initialiseer de data van de raket
public override void Initialize(GridCell _cell);

// Beweeg de raket over de boog
private void Move();

// Draai de raket over de boog
private void Rotate();

NavalMineBehaviour

namespace ShipAttackers.Mine

public class NavalMineBehaviour : ShipAttacker

Fields

// De begin hoogte van de mijn
[SerializeField] private float startHeight;

// De richting waar de mijn begint te controleren
[SerializeField] private ECompassDirection startDirection;

// De tijd die het duurt voor de mijn om naar boven te drijven
[SerializeField] private float floatCooldown;

Methods

// Initialiseer de data van de mijn
public override void Initialize(GridCell _cell);

// Val een punt op het grid aan of ontmantel de mijn
private void DismantleOrExplode();

NavalMineHandler

namespace ShipAttackers.Mine

public class NavalMineHandler : ShipAttackerHandler<NavalMineBehaviour>

Fields

// De DashboardHandler voor UI events
[SerializeField] private DashboardHandler dashboardHandler;

Methods

// Voeg een mijn toe aan het grid
public void AddMine(GridCell _cell);

// Plaats alle mijnen in de wereld
public void PlaceMines();

ShipAttacker

namespace ShipAttackers

public abstract class ShipAttacker : MonoBehaviour

Fields

// De FX die worden neergezet wanneer de attacker mist
[SerializeField] protected FXSystem missFxPrefab;

// De data met alle benodigde posities
protected AttackerData data;

Properties

// De positie in grid-coördinaten die aangevallen wordt
public Vector2Int AttackPosition { get; set; }

// Het schip dat wordt aangevallen
public ShipBehaviour Ship { get; }

Methods

// Initialiseer de data van de attacker
public virtual void Initialize(GridCell _cell);

// Genereer de mis effecten
protected void Miss();

// Val de positie aan
protected virtual bool Attack();

ShipAttackerHandler

namespace ShipAttackers

public abstract class ShipAttackerHandler<T> : MonoBehaviour where T : ShipAttacker

Fields

// De prefab van de attacker
[SerializeField] protected T attackerPrefab;

Methods

// Creëert een nieuwe attacker
protected T SpawnAttacker();

// Val de gegeven cell aan
protected virtual void AttackCell(GridCell _cell);

EShip

namespace Ships

public enum EShip

Enumerator

Schiedam,
VanAmstel,
VanSpeijk,
DeRuyter,
JohanDeWitt

PlacingIndicator

namespace Ships

[RequireComponent(typeof(MeshRenderer), typeof(MeshFilter))]
public class PlacingIndicator : MonoBehaviour

Fields

// De dikte van het frame
[SerializeField] private float thickness = 1;

// De breedte van het frame
[SerializeField] private float width = 1;

// De hoogte van het frame
[SerializeField] private float depth = 1;

// De material van het actieve en inactieve frame
[SerializeField] private Material active, inactive;

Methods

// Zet de components
public void Initialize();

// Genereer de mesh van het frame
public void GenerateMesh();

// Zet het frame actief
public void SetActive();

// Zet het frame inactief
public void SetInactive();

ShipBehaviour

namespace Ships

public class ShipBehaviour : MonoBehaviour

Fields

// De vorm van het schip
public GridShape shape;

// Gevuurd waaneer het schip is geplaatst
public UnityEvent onPlace;

// Gevuurd wanneer het schip wordt ingedrukt
public UnityEvent onClick;

// Gevuurd wanneer het schip begint met bewegen
public UnityEvent onStartMove;

// Kan dit schip mijnen ontmantellen
public bool dismantleMines;

// De grid positie van dit schip
public Vector2Int position;

// De treffer effecten van dit schip
[SerializeField] private FXSystem[] effects;

// De plaats indicator van dit schip
[SerializeField] private PlacingIndicator indicator;

// De animator van dit schip
[SerializeField] private Animator animator;

Properties

// Gevuurd wanneer het schip van het grid wordt gehaald
public UnityEvent<ShipBehaviour> OnClear { get; private set; } = new UnityEvent<ShipBehaviour>();

// Gevuurd wanneer het schip zinkt
public UnityEvent OnSink { get; private set; } = new UnityEvent();

ShipPlacer

namespace Ships

public class ShipPlacer : MonoBehaviour

Fields

// De schepen die geplaatst kunnen worden
[SerializeField] private ShipBehaviour[] ships;

Properties

// Word er een schip geplaatst
public bool IsPlacing { get; private set; } = false;

// Gevuurd wanneer het schip geplaatst is
public UnityEvent DonePlacing { get; private set; } = new UnityEvent();

Methods

// Plaats een schip met het gegeven type
public void PlaceShip(EShip ship);

ShipSink

namespace ShipSink

public class ShipSink : StateMachineBehaviour

Properties

// Gevuurd wanneer het schip begint met zinken
public UnityEvent OnStartSink {  get; private set; } = new UnityEvent();
// Gevuurd wanneer het schip stopt met zinken
public UnityEvent OnEndSink { get; private set; } = new UnityEvent();

DashboardHandler

namespace UIHandlers

[RequireComponent(typeof(UIDocument))]
public class DashboardHandler : NetworkBehaviour

Fields

// Gevuurd wanneer de speler klaar is
public UnityEvent onReady;

// Gevuurd wannneer het spel begint
public UnityEvent onGameStart;

// De scene om te laden
[SerializeField] private string loadingScene;

// De Gridhandler voor aanval events
[SerializeField] private GridHandler _gridHandler;

// De ShipPlacer voor het plaatsen van schepen
[SerializeField] private ShipPlacer _shipPlacer;

// De code text
[SerializeField] private TMP_Text _sessionCodeText;

// De knop om de code te kopiëren
[SerializeField] private UnityEngine.UI.Button _copySessionCode;

// De ids van alle schepen
[SerializeField] private string[] shipIds;

// De knop om de sessie te verlaten
[SerializeField] private UnityEngine.UI.Button _leaveSessionButton;

// De groote van het grid (breedte en hoogte)
private const byte GridSize; // const waarde: GridHandler.gridSize

// Het maximaal aantal spelers
private const byte PlayerCount; // const waarde: 2

Methods

// Zet de grid knop als een treffer
public void OnHitRpc(byte _targetCell);

// Zet de grid knop als een misser
public void OnMissRpc(byte _targetCell);

MenuHandler

namespace UIHandlers

[RequireComponent(typeof(UIDocument))]
public class MenuHandler : MonoBehaviour

Fields

// De scene om te laden
[SerializeField] private string loadingScene;

// De snel spelen knop widget
[SerializeField] private UnityEngine.UI.Button quickPlayButton;

// Het code veld widget
[SerializeField] private TMP_InputField playCodeInputField;

// De speel knop widget
[SerializeField] private UnityEngine.UI.Button playCodeButton;

CompassDirections

namespace Utilities.CompassDirections

public struct CompassDirections

Fields

// De hoeveelhijd richtingen
public const byte Directions; // const waarde: 8

Methods

// Krijg de vector van een richting
public static Vector2Int DirectionToVector(ECompassDirection direction);

// Krijg de richting van een vector
public static ECompassDirection VectorToDirection(Vector2Int direction);

// Draai de richting rechtsom
public static ECompassDirection RotateClockwise(ECompassDirection direction);

// Draai de richting rechtsom
public static Vector2Int RotateClockwiseVector2Int(ECompassDirection direction);

// Draai de richting linksom
public static ECompassDirection RotateCounterclockwise(ECompassDirection direction);

// Draai de vector linksom
public static Vector2Int RotateCounterclockwiseVector2Int(ECompassDirection direction);

ECompassDirection

namespace Utilities.CompassDirections

public enum ECompassDirection : byte

Enumerators

North,
NorthEast,
East,
SouthEast,
South,
SouthWest,
West,
NorthWest

UniqueList

namespace Utilities.Generic

public class UniqueList<T>

Constructors

public UniqueList(IEqualityComparer<T> _comparer = null);

Properties

// Krtijg de grootte van de lijst
public int Count { get; }

// Krijf/Zet een item in de lijst
public T this[int t] { get; set; }

Methods

// Voeg een nieuw item toe als die nog niet in de list staat
public bool Add(T _item);

// Verwijder de item uit de lijst
public bool Remove(T _item);

CountdownTimer

namespace Utilities.Timer

public class CountdownTimer : Timer

Properties

// Is de timer klaar
public bool IsFinished { get; }

Methods

// Progres de timer met deltaTime
public override void Tick(float deltaTime);

// Reset de timer naar de originele tijd
public void Reset();

// Reset de timer naar de nieuwe tijd
public void Reset(float newTime);

Timer

namespace Utilities.Timer

public abstract class Timer

Constructors

// Creëer eem nieuwe timer met value als eind tijd
public Timer(float value);

Fields

// De start tijd van de timer
protected float initialTime;

// De actie wanneer de timer start
public UnityAction onTimerStart = () => { };

// De actie wanneer de timer stopt
public UnityAction onTimerStop = () => { };

Properties

// De totale tijd van de timer
protected float Time { get; set; }

// Is de timer nu aan het tellen
public bool IsRunning { get; protected set; }

// De voortgang van de timer
public float Progress { get; };

Methods

// Start de timer
public void Start();

// Stop de timer
public void Stop();

// Hervat de timer
public void Resume();

// Pauzeer de timer
public void Pause();

// Een abstracte functie die wordt geroepen wanneer de timer voort gaat
public abstract void Tick(float deltaTime);

TimerHandler

namespace Utilities.Timer

public class TimerHandler : MonoBehaviour

Fields

// De singleton-instantie van de TimerHandler
public static TimerHandler instance;

Properties

// De actie die in Update wordt aangeroepen
public UnityAction<float> onTick { get; }

CellUnpacker

namespace Utilities

public struct CellUnpacker

Methods

// Krijg de cels positie als grid-coördinaat
public static Vector2Int CellPosition(byte cell);

// Krijg de cels index in het dashboard
public static byte PackCell(Vector2Int position);