tschesky/AppleHillsProduction
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

IMplement basic Developer Settings

Browse Source
This commit is contained in:
AlexanderT
2025-09-24 12:21:21 +02:00
parent f07ce88331
commit 8b96a5d0c3
18 changed files with 739 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
Assets/Scripts/Core/GameManager.cs
View File

@@ -33,7 +33,9 @@ public class GameManager : MonoBehaviour
[Header("Settings Status")]
[SerializeField] private bool _settingsLoaded = false;
[SerializeField] private bool _developerSettingsLoaded = false;
public bool SettingsLoaded => _settingsLoaded;
public bool DeveloperSettingsLoaded => _developerSettingsLoaded;
void Awake()
{
@@ -42,8 +44,12 @@ public class GameManager : MonoBehaviour
// Create settings provider if it doesn't exist
SettingsProvider.Instance.gameObject.name = "Settings Provider";
// Create developer settings provider if it doesn't exist
DeveloperSettingsProvider.Instance.gameObject.name = "Developer Settings Provider";
// Load all settings synchronously during Awake
InitializeSettings();
InitializeDeveloperSettings();
// DontDestroyOnLoad(gameObject);
}
@@ -55,7 +61,7 @@ public class GameManager : MonoBehaviour
// Load settings synchronously
var playerSettings = SettingsProvider.Instance.LoadSettingsSynchronous<PlayerFollowerSettings>();
var interactionSettings = SettingsProvider.Instance.LoadSettingsSynchronous<InteractionSettings>();
var minigameSettings = SettingsProvider.Instance.LoadSettingsSynchronous<MinigameSettings>();
var minigameSettings = SettingsProvider.Instance.LoadSettingsSynchronous<DivingMinigameSettings>();
// Register settings with service locator
if (playerSettings != null)
@@ -80,7 +86,7 @@ public class GameManager : MonoBehaviour
if (minigameSettings != null)
{
ServiceLocator.Register<IMinigameSettings>(minigameSettings);
ServiceLocator.Register<IDivingMinigameSettings>(minigameSettings);
Debug.Log("MinigameSettings registered successfully");
}
else
@@ -100,6 +106,28 @@ public class GameManager : MonoBehaviour
}
}
/// <summary>
/// Check for and initialize developer settings.
/// </summary>
private void InitializeDeveloperSettings()
{
Debug.Log("Starting developer settings initialization...");
// Load developer settings
var divingDevSettings = DeveloperSettingsProvider.Instance.GetSettings<DivingDeveloperSettings>();
_developerSettingsLoaded = divingDevSettings != null;
if (_developerSettingsLoaded)
{
Debug.Log("All developer settings loaded successfully");
}
else
{
Debug.LogWarning("Some developer settings failed to load");
}
}
void OnApplicationQuit()
{
_isQuitting = true;
@@ -112,6 +140,26 @@ public class GameManager : MonoBehaviour
return ServiceLocator.Get<T>();
}
/// <summary>
/// Returns the entire settings object of specified type.
/// </summary>
/// <typeparam name="T">Type of settings to retrieve</typeparam>
/// <returns>The settings object or null if not found</returns>
public static T GetSettingsObject<T>() where T : class
{
return Instance?.GetSettings<T>();
}
/// <summary>
/// Returns the developer settings object of specified type.
/// </summary>
/// <typeparam name="T">Type of developer settings to retrieve</typeparam>
/// <returns>The developer settings object or null if not found</returns>
public static T GetDeveloperSettings<T>() where T : BaseDeveloperSettings
{
return DeveloperSettingsProvider.Instance?.GetSettings<T>();
}
// PLAYER & FOLLOWER SETTINGS
// Player settings
@@ -178,9 +226,18 @@ public class GameManager : MonoBehaviour
// MINIGAME SETTINGS
// Endless Descender settings
public float EndlessDescenderLerpSpeed => GetSettings<IMinigameSettings>()?.EndlessDescenderLerpSpeed ?? 12f;
public float EndlessDescenderMaxOffset => GetSettings<IMinigameSettings>()?.EndlessDescenderMaxOffset ?? 3f;
public float EndlessDescenderClampXMin => GetSettings<IMinigameSettings>()?.EndlessDescenderClampXMin ?? -3.5f;
public float EndlessDescenderClampXMax => GetSettings<IMinigameSettings>()?.EndlessDescenderClampXMax ?? 3.5f;
public float EndlessDescenderSpeedExponent => GetSettings<IMinigameSettings>()?.EndlessDescenderSpeedExponent ?? 2.5f;
public float EndlessDescenderLerpSpeed => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderLerpSpeed ?? 12f;
public float EndlessDescenderMaxOffset => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderMaxOffset ?? 3f;
public float EndlessDescenderClampXMin => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderClampXMin ?? -3.5f;
public float EndlessDescenderClampXMax => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderClampXMax ?? 3.5f;
public float EndlessDescenderSpeedExponent => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderSpeedExponent ?? 2.5f;
public float EndlessDescenderTapMaxDistance => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderTapMaxDistance ?? 0.5f;
public float EndlessDescenderTapDecelerationRate => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderTapDecelerationRate ?? 5.0f;
public int EndlessDescenderInitialTileCount => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderInitialTileCount ?? 3;
public float EndlessDescenderTileSpawnBuffer => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderTileSpawnBuffer ?? 1f;
public float EndlessDescenderMoveSpeed => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderMoveSpeed ?? 3f;
public float EndlessDescenderSpeedUpFactor => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderSpeedUpFactor ?? 0.2f;
public float EndlessDescenderSpeedUpInterval => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderSpeedUpInterval ?? 10f;
public float EndlessDescenderMaxMoveSpeed => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderMaxMoveSpeed ?? 12f;
public float EndlessDescenderVelocityCalculationInterval => GetSettings<IDivingMinigameSettings>()?.EndlessDescenderVelocityCalculationInterval ?? 0.5f;
}

19
Assets/Scripts/Core/Settings/BaseDeveloperSettings.cs Normal file
View File

@@ -0,0 +1,19 @@
using UnityEngine;
namespace AppleHills.Core.Settings
{
/// <summary>
/// Base abstract class for all developer settings.
/// Developer settings are intended for technical configuration rather than gameplay/design values.
/// </summary>
public abstract class BaseDeveloperSettings : ScriptableObject
{
/// <summary>
/// Called to validate settings values when they are changed in the inspector.
/// </summary>
public virtual void OnValidate()
{
// Base implementation does nothing, override in derived classes
}
}
}

3
Assets/Scripts/Core/Settings/BaseDeveloperSettings.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 50def2e6e95a4830b57f3e1b76a4df51
timeCreated: 1758707161

95
Assets/Scripts/Core/Settings/DeveloperSettingsProvider.cs Normal file
View File

@@ -0,0 +1,95 @@
using System.Collections.Generic;
using UnityEngine;
namespace AppleHills.Core.Settings
{
/// <summary>
/// Provides access to developer settings for technical configuration rather than gameplay parameters.
/// Follows the singleton pattern for global access.
/// </summary>
public class DeveloperSettingsProvider : MonoBehaviour
{
private static DeveloperSettingsProvider _instance;
/// <summary>
/// Singleton instance of the provider.
/// </summary>
public static DeveloperSettingsProvider Instance
{
get
{
if (_instance == null && Application.isPlaying)
{
_instance = FindFirstObjectByType<DeveloperSettingsProvider>();
if (_instance == null)
{
GameObject go = new GameObject("DeveloperSettingsProvider");
_instance = go.AddComponent<DeveloperSettingsProvider>();
// Don't destroy between scenes
DontDestroyOnLoad(go);
}
}
return _instance;
}
}
// Dictionary to cache loaded settings
private Dictionary<System.Type, BaseDeveloperSettings> _settingsCache = new Dictionary<System.Type, BaseDeveloperSettings>();
// Default developer settings stored in the Resources folder
[SerializeField] private string _resourcesPath = "Settings/Developer";
private void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(gameObject);
return;
}
_instance = this;
DontDestroyOnLoad(gameObject);
// Initialize settings cache
_settingsCache = new Dictionary<System.Type, BaseDeveloperSettings>();
}
/// <summary>
/// Gets or loads developer settings of the specified type.
/// </summary>
/// <typeparam name="T">Type of developer settings to retrieve</typeparam>
/// <returns>The settings instance or null if not found</returns>
public T GetSettings<T>() where T : BaseDeveloperSettings
{
System.Type type = typeof(T);
// Return from cache if available
if (_settingsCache.TryGetValue(type, out BaseDeveloperSettings cachedSettings))
{
return cachedSettings as T;
}
// Load from Resources if not cached
T settings = Resources.Load<T>($"{_resourcesPath}/{type.Name}");
if (settings != null)
{
_settingsCache[type] = settings;
return settings;
}
Debug.LogWarning($"Developer settings of type {type.Name} not found in Resources/{_resourcesPath}");
return null;
}
/// <summary>
/// Clears the settings cache, forcing settings to be reloaded.
/// </summary>
public void ClearCache()
{
_settingsCache.Clear();
}
}
}

3
Assets/Scripts/Core/Settings/DeveloperSettingsProvider.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: f9945aa4a563434e973ab49176259150
timeCreated: 1758707186

127
Assets/Scripts/Core/Settings/DivingDeveloperSettings.cs Normal file
View File

@@ -0,0 +1,127 @@
using UnityEngine;
namespace AppleHills.Core.Settings
{
/// <summary>
/// Developer settings for the diving minigame technical configuration.
/// These settings are separate from gameplay/design settings and focus on technical implementation details.
/// </summary>
[CreateAssetMenu(fileName = "DivingDeveloperSettings", menuName = "AppleHills/Developer Settings/Diving", order = 1)]
public class DivingDeveloperSettings : BaseDeveloperSettings
{
[Header("Bubble System")]
[Tooltip("Object pooling enabled for bubbles")]
[SerializeField] private bool bubbleUseObjectPooling = true;
[Tooltip("Initial number of bubbles to pre-allocate in pool")]
[SerializeField] private int bubbleInitialPoolSize = 10;
[Tooltip("Maximum number of bubbles allowed in pool")]
[SerializeField] private int bubbleMaxPoolSize = 30;
[Tooltip("Default spawn interval for bubbles in seconds")]
[SerializeField] private float bubbleSpawnInterval = 0.3f;
[Tooltip("Range of possible bubble movement speeds (min, max)")]
[SerializeField] private Vector2 bubbleSpeedRange = new Vector2(0.5f, 2f);
[Tooltip("Range of possible bubble scale factors (min, max)")]
[SerializeField] private Vector2 bubbleScaleRange = new Vector2(0.3f, 0.7f);
[Tooltip("Range of possible bubble wobble speeds (min, max)")]
[SerializeField] private Vector2 bubbleWobbleSpeedRange = new Vector2(1f, 3f);
[Tooltip("Range of possible bubble wobble amounts (min, max)")]
[SerializeField] private Vector2 bubbleWobbleAmountRange = new Vector2(0.05f, 0.15f);
[Tooltip("Minimum X position for bubble spawning")]
[SerializeField] private float bubbleSpawnXMin = -3.5f;
[Tooltip("Maximum X position for bubble spawning")]
[SerializeField] private float bubbleSpawnXMax = 3.5f;
[Tooltip("Y position for bubble spawning")]
[SerializeField] private float bubbleSpawnY = -5f;
[Tooltip("Minimum scale factor during wobble animation")]
[SerializeField] private float bubbleWobbleMinScale = 0.2f;
[Tooltip("Maximum scale factor during wobble animation")]
[SerializeField] private float bubbleWobbleMaxScale = 1.2f;
[Tooltip("Factor to multiply bubble speed by when surfacing")]
[SerializeField] private float bubbleSurfacingSpeedFactor = 0.5f;
[Header("Obstacle System")]
[Tooltip("Layer for obstacles to be placed on")]
[SerializeField] private int obstacleLayer = 9;
[Tooltip("Layer mask for tile collision detection during obstacle spawn validation")]
[SerializeField] private LayerMask obstacleTileLayerMask = -1;
[Tooltip("Whether to use object pooling for obstacles")]
[SerializeField] private bool obstacleUseObjectPooling = true;
[Tooltip("Maximum objects per prefab type in obstacle pool")]
[SerializeField] private int obstacleMaxPerPrefabPoolSize = 3;
[Tooltip("Total maximum size of obstacle pool across all prefab types")]
[SerializeField] private int obstacleTotalMaxPoolSize = 15;
// Bubble properties access
public bool BubbleUseObjectPooling => bubbleUseObjectPooling;
public int BubbleInitialPoolSize => bubbleInitialPoolSize;
public int BubbleMaxPoolSize => bubbleMaxPoolSize;
public float BubbleSpawnInterval => bubbleSpawnInterval;
public Vector2 BubbleSpeedRange => bubbleSpeedRange;
public Vector2 BubbleScaleRange => bubbleScaleRange;
public Vector2 BubbleWobbleSpeedRange => bubbleWobbleSpeedRange;
public Vector2 BubbleWobbleAmountRange => bubbleWobbleAmountRange;
public float BubbleSpawnXMin => bubbleSpawnXMin;
public float BubbleSpawnXMax => bubbleSpawnXMax;
public float BubbleSpawnY => bubbleSpawnY;
public float BubbleWobbleMinScale => bubbleWobbleMinScale;
public float BubbleWobbleMaxScale => bubbleWobbleMaxScale;
public float BubbleSurfacingSpeedFactor => bubbleSurfacingSpeedFactor;
// Obstacle properties access
public int ObstacleLayer => obstacleLayer;
public LayerMask ObstacleTileLayerMask => obstacleTileLayerMask;
public bool ObstacleUseObjectPooling => obstacleUseObjectPooling;
public int ObstacleMaxPerPrefabPoolSize => obstacleMaxPerPrefabPoolSize;
public int ObstacleTotalMaxPoolSize => obstacleTotalMaxPoolSize;
public override void OnValidate()
{
base.OnValidate();
// Validate bubble settings
bubbleInitialPoolSize = Mathf.Max(1, bubbleInitialPoolSize);
bubbleMaxPoolSize = Mathf.Max(bubbleInitialPoolSize, bubbleMaxPoolSize);
bubbleSpawnInterval = Mathf.Max(0.05f, bubbleSpawnInterval);
bubbleSpeedRange = new Vector2(
Mathf.Max(0.1f, bubbleSpeedRange.x),
Mathf.Max(bubbleSpeedRange.x, bubbleSpeedRange.y)
);
bubbleScaleRange = new Vector2(
Mathf.Max(0.1f, bubbleScaleRange.x),
Mathf.Max(bubbleScaleRange.x, bubbleScaleRange.y)
);
bubbleWobbleSpeedRange = new Vector2(
Mathf.Max(0.1f, bubbleWobbleSpeedRange.x),
Mathf.Max(bubbleWobbleSpeedRange.x, bubbleWobbleSpeedRange.y)
);
bubbleWobbleAmountRange = new Vector2(
Mathf.Max(0.01f, bubbleWobbleAmountRange.x),
Mathf.Max(bubbleWobbleAmountRange.x, bubbleWobbleAmountRange.y)
);
bubbleWobbleMinScale = Mathf.Max(0.01f, bubbleWobbleMinScale);
bubbleWobbleMaxScale = Mathf.Max(bubbleWobbleMinScale, bubbleWobbleMaxScale);
bubbleSurfacingSpeedFactor = Mathf.Max(0.01f, bubbleSurfacingSpeedFactor);
// Validate obstacle settings
obstacleMaxPerPrefabPoolSize = Mathf.Max(1, obstacleMaxPerPrefabPoolSize);
obstacleTotalMaxPoolSize = Mathf.Max(obstacleMaxPerPrefabPoolSize, obstacleTotalMaxPoolSize);
}
}
}

3
Assets/Scripts/Core/Settings/DivingDeveloperSettings.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 033961b12e7b4289838d554c2264bacd
timeCreated: 1758707215

210
Assets/Scripts/Core/Settings/DivingMinigameSettings.cs Normal file
View File

@@ -0,0 +1,210 @@
using UnityEngine;
namespace AppleHills.Core.Settings
{
/// <summary>
/// Settings related to minigames
/// </summary>
[CreateAssetMenu(fileName = "MinigameSettings", menuName = "AppleHills/Settings/Minigames", order = 3)]
public class DivingMinigameSettings : BaseSettings, IDivingMinigameSettings
{
[Header("Endless Descender - Basic Movement")]
[Tooltip("How quickly the character follows the finger horizontally (higher = more responsive)")]
[SerializeField] private float endlessDescenderLerpSpeed = 12f;
[Tooltip("Maximum horizontal offset allowed between character and finger position")]
[SerializeField] private float endlessDescenderMaxOffset = 3f;
[Tooltip("Minimum allowed X position for endless descender movement")]
[SerializeField] private float endlessDescenderClampXMin = -3.5f;
[Tooltip("Maximum allowed X position for endless descender movement")]
[SerializeField] private float endlessDescenderClampXMax = 3.5f;
[Tooltip("Exponent for speed drop-off curve (higher = sharper drop near target)")]
[SerializeField] private float endlessDescenderSpeedExponent = 2.5f;
[Header("Endless Descender - Player Movement")]
[Tooltip("Maximum distance the player can move from a single tap")]
[SerializeField] private float endlessDescenderTapMaxDistance = 0.5f;
[Tooltip("How quickly the tap impulse fades (higher = faster stop)")]
[SerializeField] private float endlessDescenderTapDecelerationRate = 5.0f;
[Header("Endless Descender - Monster Spawning")]
[Tooltip("Base chance (0-1) of spawning a monster on each tile")]
[SerializeField] private float endlessDescenderBaseSpawnProbability = 0.2f;
[Tooltip("Maximum chance (0-1) of spawning a monster")]
[SerializeField] private float endlessDescenderMaxSpawnProbability = 0.5f;
[Tooltip("How fast the probability increases per second")]
[SerializeField] private float endlessDescenderProbabilityIncreaseRate = 0.01f;
[Tooltip("Force a spawn after this many seconds without spawns")]
[SerializeField] private float endlessDescenderGuaranteedSpawnTime = 30f;
[Tooltip("Minimum time between monster spawns")]
[SerializeField] private float endlessDescenderSpawnCooldown = 5f;
[Header("Endless Descender - Scoring")]
[Tooltip("Base points for taking a picture")]
[SerializeField] private int endlessDescenderBasePoints = 100;
[Tooltip("Additional points per depth unit")]
[SerializeField] private int endlessDescenderDepthMultiplier = 10;
[Header("Endless Descender - Surfacing")]
[Tooltip("Duration in seconds for speed transition when surfacing")]
[SerializeField] private float endlessDescenderSpeedTransitionDuration = 2.0f;
[Tooltip("Factor to multiply speed by when surfacing (usually 1.0 for same speed)")]
[SerializeField] private float endlessDescenderSurfacingSpeedFactor = 3.0f;
[Tooltip("How long to continue spawning tiles after surfacing begins (seconds)")]
[SerializeField] private float endlessDescenderSurfacingSpawnDelay = 5.0f;
[Header("Endless Descender - Tile Generation")]
[Tooltip("Initial number of tiles to create at start")]
[SerializeField] private int endlessDescenderInitialTileCount = 3;
[Tooltip("Buffer distance for spawning new tiles")]
[SerializeField] private float endlessDescenderTileSpawnBuffer = 1f;
[Tooltip("Base movement speed for tiles")]
[SerializeField] private float endlessDescenderMoveSpeed = 3f;
[Tooltip("Factor to increase speed by each interval")]
[SerializeField] private float endlessDescenderSpeedUpFactor = 0.2f;
[Tooltip("Time interval between speed increases (seconds)")]
[SerializeField] private float endlessDescenderSpeedUpInterval = 10f;
[Tooltip("Maximum movement speed allowed")]
[SerializeField] private float endlessDescenderMaxMoveSpeed = 12f;
[Tooltip("Interval for velocity calculations (seconds)")]
[SerializeField] private float endlessDescenderVelocityCalculationInterval = 0.5f;
[Header("Endless Descender - Obstacles")]
[Tooltip("Time interval between obstacle spawn attempts (in seconds)")]
[SerializeField] private float endlessDescenderObstacleSpawnInterval = 2f;
[Tooltip("Random variation in obstacle spawn timing (+/- seconds)")]
[SerializeField] private float endlessDescenderObstacleSpawnIntervalVariation = 0.5f;
[Tooltip("Maximum number of obstacle spawn position attempts before skipping")]
[SerializeField] private int endlessDescenderObstacleMaxSpawnAttempts = 10;
[Tooltip("Radius around obstacle spawn point to check for tile collisions")]
[SerializeField] private float endlessDescenderObstacleSpawnCollisionRadius = 1f;
[Tooltip("Minimum movement speed for spawned obstacles")]
[SerializeField] private float endlessDescenderObstacleMinMoveSpeed = 1f;
[Tooltip("Maximum movement speed for spawned obstacles")]
[SerializeField] private float endlessDescenderObstacleMaxMoveSpeed = 4f;
// IMinigameSettings implementation - Basic Movement
public float EndlessDescenderLerpSpeed => endlessDescenderLerpSpeed;
public float EndlessDescenderMaxOffset => endlessDescenderMaxOffset;
public float EndlessDescenderClampXMin => endlessDescenderClampXMin;
public float EndlessDescenderClampXMax => endlessDescenderClampXMax;
public float EndlessDescenderSpeedExponent => endlessDescenderSpeedExponent;
// IMinigameSettings implementation - Player Movement
public float EndlessDescenderTapMaxDistance => endlessDescenderTapMaxDistance;
public float EndlessDescenderTapDecelerationRate => endlessDescenderTapDecelerationRate;
// IMinigameSettings implementation - Monster Spawning
public float EndlessDescenderBaseSpawnProbability => endlessDescenderBaseSpawnProbability;
public float EndlessDescenderMaxSpawnProbability => endlessDescenderMaxSpawnProbability;
public float EndlessDescenderProbabilityIncreaseRate => endlessDescenderProbabilityIncreaseRate;
public float EndlessDescenderGuaranteedSpawnTime => endlessDescenderGuaranteedSpawnTime;
public float EndlessDescenderSpawnCooldown => endlessDescenderSpawnCooldown;
// IMinigameSettings implementation - Scoring
public int EndlessDescenderBasePoints => endlessDescenderBasePoints;
public int EndlessDescenderDepthMultiplier => endlessDescenderDepthMultiplier;
// IMinigameSettings implementation - Surfacing
public float EndlessDescenderSpeedTransitionDuration => endlessDescenderSpeedTransitionDuration;
public float EndlessDescenderSurfacingSpeedFactor => endlessDescenderSurfacingSpeedFactor;
public float EndlessDescenderSurfacingSpawnDelay => endlessDescenderSurfacingSpawnDelay;
// IMinigameSettings implementation - Tile Generation
public int EndlessDescenderInitialTileCount => endlessDescenderInitialTileCount;
public float EndlessDescenderTileSpawnBuffer => endlessDescenderTileSpawnBuffer;
public float EndlessDescenderMoveSpeed => endlessDescenderMoveSpeed;
public float EndlessDescenderSpeedUpFactor => endlessDescenderSpeedUpFactor;
public float EndlessDescenderSpeedUpInterval => endlessDescenderSpeedUpInterval;
public float EndlessDescenderMaxMoveSpeed => endlessDescenderMaxMoveSpeed;
public float EndlessDescenderVelocityCalculationInterval => endlessDescenderVelocityCalculationInterval;
// IMinigameSettings implementation - Obstacles
public float EndlessDescenderObstacleSpawnInterval => endlessDescenderObstacleSpawnInterval;
public float EndlessDescenderObstacleSpawnIntervalVariation => endlessDescenderObstacleSpawnIntervalVariation;
public int EndlessDescenderObstacleMaxSpawnAttempts => endlessDescenderObstacleMaxSpawnAttempts;
public float EndlessDescenderObstacleSpawnCollisionRadius => endlessDescenderObstacleSpawnCollisionRadius;
public float EndlessDescenderObstacleMinMoveSpeed => endlessDescenderObstacleMinMoveSpeed;
public float EndlessDescenderObstacleMaxMoveSpeed => endlessDescenderObstacleMaxMoveSpeed;
public override void OnValidate()
{
base.OnValidate();
// Validate basic movement values
endlessDescenderLerpSpeed = Mathf.Max(0.1f, endlessDescenderLerpSpeed);
endlessDescenderMaxOffset = Mathf.Max(0.1f, endlessDescenderMaxOffset);
endlessDescenderSpeedExponent = Mathf.Max(0.1f, endlessDescenderSpeedExponent);
// Ensure min is less than max for clamping
if (endlessDescenderClampXMin >= endlessDescenderClampXMax)
{
endlessDescenderClampXMin = endlessDescenderClampXMax - 0.1f;
}
// Validate player movement
endlessDescenderTapMaxDistance = Mathf.Max(0.01f, endlessDescenderTapMaxDistance);
endlessDescenderTapDecelerationRate = Mathf.Max(0.1f, endlessDescenderTapDecelerationRate);
// Validate probability values
endlessDescenderBaseSpawnProbability = Mathf.Clamp01(endlessDescenderBaseSpawnProbability);
endlessDescenderMaxSpawnProbability = Mathf.Clamp01(endlessDescenderMaxSpawnProbability);
endlessDescenderProbabilityIncreaseRate = Mathf.Max(0f, endlessDescenderProbabilityIncreaseRate);
// Ensure max probability is at least base probability
if (endlessDescenderMaxSpawnProbability < endlessDescenderBaseSpawnProbability)
{
endlessDescenderMaxSpawnProbability = endlessDescenderBaseSpawnProbability;
}
// Validate time values
endlessDescenderGuaranteedSpawnTime = Mathf.Max(0.1f, endlessDescenderGuaranteedSpawnTime);
endlessDescenderSpawnCooldown = Mathf.Max(0.1f, endlessDescenderSpawnCooldown);
endlessDescenderSpeedTransitionDuration = Mathf.Max(0.1f, endlessDescenderSpeedTransitionDuration);
endlessDescenderSurfacingSpawnDelay = Mathf.Max(0f, endlessDescenderSurfacingSpawnDelay);
// Validate scoring
endlessDescenderBasePoints = Mathf.Max(0, endlessDescenderBasePoints);
endlessDescenderDepthMultiplier = Mathf.Max(0, endlessDescenderDepthMultiplier);
// Validate tile generation
endlessDescenderInitialTileCount = Mathf.Max(1, endlessDescenderInitialTileCount);
endlessDescenderTileSpawnBuffer = Mathf.Max(0f, endlessDescenderTileSpawnBuffer);
endlessDescenderMoveSpeed = Mathf.Max(0.1f, endlessDescenderMoveSpeed);
endlessDescenderSpeedUpFactor = Mathf.Max(0f, endlessDescenderSpeedUpFactor);
endlessDescenderSpeedUpInterval = Mathf.Max(0.1f, endlessDescenderSpeedUpInterval);
endlessDescenderMaxMoveSpeed = Mathf.Max(endlessDescenderMoveSpeed, endlessDescenderMaxMoveSpeed);
endlessDescenderVelocityCalculationInterval = Mathf.Max(0.01f, endlessDescenderVelocityCalculationInterval);
// Validate obstacle values
endlessDescenderObstacleSpawnInterval = Mathf.Max(0.1f, endlessDescenderObstacleSpawnInterval);
endlessDescenderObstacleSpawnIntervalVariation = Mathf.Max(0f, endlessDescenderObstacleSpawnIntervalVariation);
endlessDescenderObstacleMaxSpawnAttempts = Mathf.Max(1, endlessDescenderObstacleMaxSpawnAttempts);
endlessDescenderObstacleSpawnCollisionRadius = Mathf.Max(0.1f, endlessDescenderObstacleSpawnCollisionRadius);
endlessDescenderObstacleMinMoveSpeed = Mathf.Max(0.1f, endlessDescenderObstacleMinMoveSpeed);
endlessDescenderObstacleMaxMoveSpeed = Mathf.Max(endlessDescenderObstacleMinMoveSpeed, endlessDescenderObstacleMaxMoveSpeed);
}
}
}

0
Assets/Scripts/Core/Settings/MinigameSettings.cs.meta → Assets/Scripts/Core/Settings/DivingMinigameSettings.cs.meta
View File

49
Assets/Scripts/Core/Settings/MinigameSettings.cs
View File

@@ -1,49 +0,0 @@
using UnityEngine;
namespace AppleHills.Core.Settings
{
/// <summary>
/// Settings related to minigames
/// </summary>
[CreateAssetMenu(fileName = "MinigameSettings", menuName = "AppleHills/Settings/Minigames", order = 3)]
public class MinigameSettings : BaseSettings, IMinigameSettings
{
[Header("Endless Descender Settings")]
[Tooltip("How quickly the character follows the finger horizontally (higher = more responsive)")]
[SerializeField] private float endlessDescenderLerpSpeed = 12f;
[Tooltip("Maximum horizontal offset allowed between character and finger position")]
[SerializeField] private float endlessDescenderMaxOffset = 3f;
[Tooltip("Minimum allowed X position for endless descender movement")]
[SerializeField] private float endlessDescenderClampXMin = -3.5f;
[Tooltip("Maximum allowed X position for endless descender movement")]
[SerializeField] private float endlessDescenderClampXMax = 3.5f;
[Tooltip("Exponent for speed drop-off curve (higher = sharper drop near target)")]
[SerializeField] private float endlessDescenderSpeedExponent = 2.5f;
// IMinigameSettings implementation
public float EndlessDescenderLerpSpeed => endlessDescenderLerpSpeed;
public float EndlessDescenderMaxOffset => endlessDescenderMaxOffset;
public float EndlessDescenderClampXMin => endlessDescenderClampXMin;
public float EndlessDescenderClampXMax => endlessDescenderClampXMax;
public float EndlessDescenderSpeedExponent => endlessDescenderSpeedExponent;
public override void OnValidate()
{
base.OnValidate();
// Validate values
endlessDescenderLerpSpeed = Mathf.Max(0.1f, endlessDescenderLerpSpeed);
endlessDescenderMaxOffset = Mathf.Max(0.1f, endlessDescenderMaxOffset);
endlessDescenderSpeedExponent = Mathf.Max(0.1f, endlessDescenderSpeedExponent);
// Ensure min is less than max
if (endlessDescenderClampXMin >= endlessDescenderClampXMax)
{
endlessDescenderClampXMin = endlessDescenderClampXMax - 0.1f;
}
}
}
}

41
Assets/Scripts/Core/Settings/SettingsInterfaces.cs
View File

@@ -43,13 +43,50 @@ namespace AppleHills.Core.Settings
/// <summary>
/// Interface for minigame settings
/// </summary>
public interface IMinigameSettings
public interface IDivingMinigameSettings
{
// Endless Descender settings
// Endless Descender settings - Basic Movement
float EndlessDescenderLerpSpeed { get; }
float EndlessDescenderMaxOffset { get; }
float EndlessDescenderClampXMin { get; }
float EndlessDescenderClampXMax { get; }
float EndlessDescenderSpeedExponent { get; }
// Endless Descender - Player Movement
float EndlessDescenderTapMaxDistance { get; }
float EndlessDescenderTapDecelerationRate { get; }
// Endless Descender - Monster Spawning
float EndlessDescenderBaseSpawnProbability { get; }
float EndlessDescenderMaxSpawnProbability { get; }
float EndlessDescenderProbabilityIncreaseRate { get; }
float EndlessDescenderGuaranteedSpawnTime { get; }
float EndlessDescenderSpawnCooldown { get; }
// Endless Descender - Scoring
int EndlessDescenderBasePoints { get; }
int EndlessDescenderDepthMultiplier { get; }
// Endless Descender - Surfacing
float EndlessDescenderSpeedTransitionDuration { get; }
float EndlessDescenderSurfacingSpeedFactor { get; }
float EndlessDescenderSurfacingSpawnDelay { get; }
// Endless Descender - Tile Generation
int EndlessDescenderInitialTileCount { get; }
float EndlessDescenderTileSpawnBuffer { get; }
float EndlessDescenderMoveSpeed { get; }
float EndlessDescenderSpeedUpFactor { get; }
float EndlessDescenderSpeedUpInterval { get; }
float EndlessDescenderMaxMoveSpeed { get; }
float EndlessDescenderVelocityCalculationInterval { get; }
// Endless Descender - Obstacles
float EndlessDescenderObstacleSpawnInterval { get; }
float EndlessDescenderObstacleSpawnIntervalVariation { get; }
int EndlessDescenderObstacleMaxSpawnAttempts { get; }
float EndlessDescenderObstacleSpawnCollisionRadius { get; }
float EndlessDescenderObstacleMinMoveSpeed { get; }
float EndlessDescenderObstacleMaxMoveSpeed { get; }
}
}