Grundlagen für Effizienz und Arbeitssicherheit geschaffen

3d Prototyp/Assets/Scripts/Developer.cs

@@ -1,16 +1,63 @@
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
+using UnityEngine.Serialization;
 
 public class Developer : MonoBehaviour
 {
+    private string _name;
+    
     /// <summary>
-    /// Gibt die Effizienz des Entwicklers in Prozent zurück.
+    /// Manche Entwickler sind einfach effizienter als andere.
     /// </summary>
-    public float Efficiency => 1.0f;
+    [SerializeField]
+    private double _baseEfficiency = 1.0;
+
+    [SerializeField, ShowOnly]
+    private double currentCurrentEfficiency = 1.0;
+    
+    /// <summary>
+    /// Ich hoffe, dass der Entwickler eine Arbeitsunfähigkeitsversicherung hat.
+    /// </summary>
+    [SerializeField]
+    private int _fingersLeft = 10;
+    
+    /// <summary>
+    /// Gibt die Grundeffizienz des Entwicklers zurück.
+    /// </summary>
+    public double BaseEfficiency => _baseEfficiency;
+
+    /// <summary>
+    /// Gibt die Anzahl der Finger zurück.
+    /// </summary>
+    public int FingersLeft => _fingersLeft;
+    
+    /// <summary>
+    /// Gibt die aktuelle Effizienz des Entwicklers in Prozent zurück.
+    /// </summary>
+    public double CurrentEfficiency => currentCurrentEfficiency;
+
+    public string Name => _name;
     
     public void UpdateEfficiency()
     {
-        // TODO: Implement 
+        currentCurrentEfficiency = _baseEfficiency * (_fingersLeft / 10.0);
+    }
+
+    /// <summary>
+    /// Der Entwickler wird verletzt und der Idiot bricht sich ausgerechnet einen Finger...
+    /// </summary>
+    public void Hurt()
+    {
+        _fingersLeft--;
+
+        // Ob er stirbt oder nicht, für uns hat er auf jeden Fall seinen Nutzen verloren.
+        if (_fingersLeft == 0)
+            Die();
+    }
+
+    private void Die()
+    {
+        Debug.Log($"{Name} ist verreckt.");
     }
 }

3d Prototyp/Assets/Scripts/GameManager.cs

@@ -20,8 +20,11 @@ public class GameManager : MonoBehaviour
     [SerializeField]
     private List<Developer> _developers = new();
 
+    [SerializeField]
+    private MultiFalsableBool _gameRunning = new(false);
+    
     /// <summary>
-    /// Wie weit das Spiel bereits fortgeschritten ist, in Prozent.
+    /// Wie weit das Spiel bereits fortgeschritten ist.
     /// </summary>
     public double GameProgress => 1.0 - (_remainingGameDurationSeconds / _baseGameDurationSeconds);
     
@@ -31,10 +34,12 @@ public class GameManager : MonoBehaviour
     public double CurrentEfficiency => _currentEfficiency;
     
     /// <summary>
-    /// Wie viele Sekunden das Spiel voraussichtlich noch dauern wird, würden die Effizienz sich nicht verändern.
+    /// Wie viele Sekunden das Spiel voraussichtlich noch dauern wird, würde die Effizienz sich nicht verändern.
     /// </summary>
     public double ExpectedRemainingGameDuration => _remainingGameDurationSeconds / _currentEfficiency;
 
+    public bool IsGameRunning => _gameRunning.IsTrue;
+    
     private void Awake()
     {
         if (Instance == null)
@@ -46,13 +51,47 @@ public class GameManager : MonoBehaviour
             Debug.LogError("GameManager already exists. Deleting duplicate.");
             Destroy(gameObject);
         }
-        
-        InvokeRepeating(nameof(UpdateProgress), 0.0f, 1.0f);
     }
 
     private void Start()
+    {
+        StartGame();
+    }
+
+
+    /// <summary>
+    /// Startet ein neues Spiel.
+    /// </summary>
+    [ContextMenu("Start Game")]
+    private void StartGame()
     {
         _remainingGameDurationSeconds = _baseGameDurationSeconds;
+
+        ResumeGame();   
+    }
+
+    /// <summary>
+    /// Hebt eine Pausierung auf und setzt das Spiel fort, wenn alle Pausierungen aufgehoben wurden.
+    /// </summary>
+    /// <remarks>Hinweis: Für jedes PauseGame muss ein ResumeGame aufgerufen werden.</remarks>
+    [ContextMenu("Resume Game")]
+    public void ResumeGame()
+    {
+        if (_gameRunning.MakeTruer())
+        {
+            InvokeRepeating(nameof(UpdateProgress), 0.0f, 1.0f);    
+        }
+    }
+
+    /// <summary>
+    /// Pausiert das Spiel. Ist Stapelbar.
+    /// </summary>
+    /// <remarks>Hinweis: Für jedes PauseGame muss ein ResumeGame aufgerufen werden.</remarks>
+    [ContextMenu("Pause Game")]
+    public void PauseGame()
+    {
+        _gameRunning.MakeFalslier();
+        CancelInvoke(nameof(UpdateProgress));
     }
     
     void UpdateProgress()
@@ -68,7 +107,7 @@ public class GameManager : MonoBehaviour
         foreach (Developer developer in _developers)
         {
             developer.UpdateEfficiency();
-            developerEfficiency += developer.Efficiency;
+            developerEfficiency += developer.CurrentEfficiency;
         }
         
         _currentEfficiency = developerEfficiency;

3d Prototyp/Assets/Scripts/MultiFalsableBool.cs

@@ -0,0 +1,53 @@
+using System;
+using UnityEngine;
+
+/// <summary>
+/// Stell dir vor, du hättest einen Bool und der könnte einfach mehrmals falsch sein. Wäre das nicht total cool?
+/// </summary>
+[Serializable]
+public struct MultiFalsableBool
+{
+    [SerializeField]
+    private int _falseness;
+
+    public bool IsTrue => _falseness == 0;
+    public bool IsFalse => _falseness > 0;
+
+    /// <summary>
+    /// Macht den bool noch falscher als er vorher war. Wenn er vorher wahr wahr, dann ist er jetzt definitiv falsch.
+    /// </summary>
+    /// <returns>Der neue Wert.</returns>
+    public bool MakeFalslier()
+    {
+        _falseness++;
+
+        return this;
+    }
+
+    /// <summary>
+    /// Macht den bool nicht wahr, sondern lediglich wahrer als er vorher wahr. Wenn er allerdings nur einfach falsch wahr, dann ist er jetzt wahr.
+    /// Wenn er vorher wahr war, bleibt er wahr.
+    /// </summary>
+    /// <returns>Der neue Wert.</returns>
+    public bool MakeTruer()
+    {
+        if (_falseness > 0)
+            _falseness--;
+
+        return this;
+    }
+
+    public MultiFalsableBool(bool value) => _falseness = value ? 0 : 1;
+    
+    /// <summary>
+    /// Erzeugt eine neue Instanz von MultiFalsableBool und initialisiert diese mit dem gegebenen Wert.
+    /// </summary>
+    /// <param name="value">Der Wert, der angibt, wie falsch der bool ist.</param>
+    public MultiFalsableBool(int value) => _falseness = (value > 0 ? value : 0);
+    
+    public static implicit operator bool(MultiFalsableBool value) => value.IsTrue;
+
+    public static bool operator ==(MultiFalsableBool a, bool b) => a.IsTrue == b;
+
+    public static bool operator !=(MultiFalsableBool a, bool b) => a.IsTrue != b;
+}

3d Prototyp/Assets/Scripts/MultiFalsableBool.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bc62ec449b954b119f12024eac70da9b
+timeCreated: 1712244471

3d Prototyp/Assets/Scripts/ValueStack.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+
+/// <summary>
+/// Ermöglicht das erstellen einer Variable mit gestapeltem Wert, sodass überschreiben und zurücksetzen möglich ist.
+/// </summary>
+public class ValueStack<T> : Stack<T>
+{
+	/// <summary>
+	/// Erzeugt eine neue Instanz des ValueStacks und initialisiert diesen mit dem Standardwert.
+	/// </summary>
+	public ValueStack()
+	{
+		Push(default);
+	}
+	
+	/// <summary>
+	/// Erzeugt eine neue Instanz des ValueStacks und initialisiert diesen mit dem gegebenen Wert.
+	/// </summary>
+	/// <param name="initialValue">Der Wert, mit dem der Stack initialisiert werden soll.</param>
+	public ValueStack(T initialValue)
+	{
+		Push(initialValue);
+	}
+	
+	/// <summary>
+	/// Setzt den Wert des Stacks auf den gegebenen Wert.
+	/// </summary>
+	/// <param name="value">Der Wert, auf den der Stack gesetzt werden soll.</param>
+	/// <returns>Der gegebene Wert um Verkettung von Expression zu ermöglichen.</returns>
+    public new T Push(T value)
+    {
+        base.Push(value);
+
+        return value;
+    }
+
+	/// <summary>
+	/// Popt den obersten Wert des Stacks, wenn der Stack nur noch einen Wert enthält, wird nicht gepopt und dieser zurückgegeben.
+	/// </summary>
+    public new T Pop()
+    {
+	    if (Count == 1)
+		    return Peek();
+
+	    return base.Pop();
+    }
+
+    /// <summary>
+    /// Gibt den aktuellen Wert des ValueStacks zurück.
+    /// </summary>
+    public T CurrentValue() => Peek();
+    
+    public static implicit operator T(ValueStack<T> stack) => stack.CurrentValue();
+}

3d Prototyp/Assets/Scripts/ValueStack.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c7221cc10b464cef9d2e892b110099d5
+timeCreated: 1712243859