224 lines
No EOL
7 KiB
GDScript
224 lines
No EOL
7 KiB
GDScript
class_name UnlockDataResource
|
|
extends Resource
|
|
|
|
@export var unlock_id: int = 0
|
|
@export var unlock_name: String = ""
|
|
@export var unlock_description: String = ""
|
|
@export var base_cost: int = 0
|
|
@export var is_unlocked: bool = false
|
|
|
|
@export_group("Scaling Settings")
|
|
@export var is_scaling: bool = false
|
|
@export var current_rank: int = 0
|
|
@export var max_rank: int = -1 # -1 means infinite scaling
|
|
|
|
@export_subgroup("Cost Scaling")
|
|
@export_enum("Linear", "Exponential") var cost_scaling_type: int = 1 # Default to Exponential
|
|
@export var cost_scaling_multiplier: float = 1.5 # Exponential: multiplier per rank, Linear: flat increase
|
|
@export var cost_linear_increase: int = 100 # Only used if cost_scaling_type is Linear
|
|
@export var cost_ladder: Array[int] = [] # Fixed costs per rank (overrides scaling if defined)
|
|
|
|
@export_subgroup("Effect Scaling")
|
|
@export_enum("Linear", "Exponential") var effect_scaling_type: int = 1 # Default to Exponential
|
|
@export var effect_scaling_multiplier: float = 1.2 # Exponential: multiplier per rank
|
|
@export var effect_linear_increase: float = 0.1 # Linear: flat increase per rank (e.g., 0.1 = +10% per rank)
|
|
|
|
@export_group("Base Modifiers")
|
|
@export var base_modifiers: Dictionary = {}
|
|
|
|
## Returns the cost for the next rank/unlock
|
|
func get_next_cost() -> int:
|
|
if not is_scaling:
|
|
return base_cost
|
|
|
|
# Use fixed cost ladder if defined (overrides scaling)
|
|
if cost_ladder.size() > 0 and current_rank < cost_ladder.size():
|
|
return cost_ladder[current_rank]
|
|
|
|
# Fallback to scaling formulas for backwards compatibility
|
|
# Cost scaling should start from rank 0 (first purchase at base_cost)
|
|
if cost_scaling_type == 0: # Linear
|
|
return base_cost + (cost_linear_increase * current_rank)
|
|
else: # Exponential
|
|
return int(base_cost * pow(cost_scaling_multiplier, current_rank))
|
|
|
|
## Returns the current modifiers based on rank
|
|
func get_current_modifiers() -> Dictionary:
|
|
# If not unlocked yet, return empty modifiers
|
|
if not is_unlocked or current_rank == 0:
|
|
return {}
|
|
|
|
# Rank 1 should give base modifiers without scaling
|
|
if current_rank == 1:
|
|
return base_modifiers.duplicate()
|
|
|
|
# Rank 2+ applies scaling
|
|
return get_modifiers_at_rank(current_rank)
|
|
|
|
## Returns modifiers for a specific rank (useful for preview)
|
|
func get_modifiers_at_rank(rank: int) -> Dictionary:
|
|
if not is_scaling or rank == 0:
|
|
return base_modifiers.duplicate()
|
|
|
|
# Rank 1 returns base modifiers without scaling
|
|
if rank == 1:
|
|
return base_modifiers.duplicate()
|
|
|
|
var scaled_modifiers = {}
|
|
for key in base_modifiers.keys():
|
|
var base_value = base_modifiers[key]
|
|
|
|
if effect_scaling_type == 0: # Linear scaling
|
|
# Linear: add flat increase per rank above 1
|
|
# e.g., base 1.5 (+50%), linear 0.1 (+10%), rank 2 = 1.6 (+60%), rank 3 = 1.7 (+70%)
|
|
var additional_ranks = rank - 1
|
|
scaled_modifiers[key] = base_value + (effect_linear_increase * additional_ranks)
|
|
else: # Exponential scaling
|
|
# Exponential: scale the bonus part from rank 1
|
|
# The bonus at rank 1 is (base_value - 1.0)
|
|
# At higher ranks, multiply this bonus by multiplier^(rank-1)
|
|
var base_bonus = base_value - 1.0
|
|
var scaled_bonus = base_bonus * pow(effect_scaling_multiplier, rank - 1)
|
|
scaled_modifiers[key] = 1.0 + scaled_bonus
|
|
|
|
return scaled_modifiers
|
|
|
|
## Convert a modifier value to a percentage string
|
|
func _modifier_to_percentage(value: float) -> String:
|
|
var percentage = (value - 1.0) * 100.0
|
|
if percentage >= 0:
|
|
return "+%.1f%%" % percentage
|
|
else:
|
|
return "%.1f%%" % percentage
|
|
|
|
## Get a formatted string of current modifiers with percentages
|
|
func get_current_modifiers_string() -> String:
|
|
var modifiers = get_current_modifiers()
|
|
if modifiers.is_empty():
|
|
return "No modifiers"
|
|
|
|
var lines = []
|
|
for key in modifiers.keys():
|
|
var display_name = key.replace("_", " ").capitalize()
|
|
var percentage = _modifier_to_percentage(modifiers[key])
|
|
lines.append("%s: %s" % [display_name, percentage])
|
|
|
|
return "\n".join(lines)
|
|
|
|
## Get a formatted string of next rank modifiers with percentages
|
|
func get_next_modifiers_string() -> String:
|
|
if not can_rank_up():
|
|
return "Max rank reached"
|
|
|
|
var next_rank = get_next_rank()
|
|
var modifiers = get_modifiers_at_rank(next_rank)
|
|
|
|
if modifiers.is_empty():
|
|
return "No modifiers"
|
|
|
|
var lines = []
|
|
for key in modifiers.keys():
|
|
var display_name = key.replace("_", " ").capitalize()
|
|
var percentage = _modifier_to_percentage(modifiers[key])
|
|
lines.append("%s: %s" % [display_name, percentage])
|
|
|
|
return "\n".join(lines)
|
|
|
|
## Get comparison string showing current -> next modifiers
|
|
func get_modifiers_comparison_string() -> String:
|
|
if not can_rank_up():
|
|
return get_current_modifiers_string()
|
|
|
|
var current = get_current_modifiers()
|
|
var next_rank = get_next_rank()
|
|
var next = get_modifiers_at_rank(next_rank)
|
|
|
|
# If no current modifiers (not unlocked yet), show next only
|
|
if current.is_empty():
|
|
var lines = []
|
|
for key in next.keys():
|
|
var display_name = key.replace("_", " ").capitalize()
|
|
var next_pct = _modifier_to_percentage(next[key])
|
|
lines.append("%s: %s" % [display_name, next_pct])
|
|
return "\n".join(lines)
|
|
|
|
var lines = []
|
|
for key in current.keys():
|
|
var display_name = key.replace("_", " ").capitalize()
|
|
var current_pct = _modifier_to_percentage(current[key])
|
|
var next_pct = _modifier_to_percentage(next[key])
|
|
lines.append("%s: %s → %s" % [display_name, current_pct, next_pct])
|
|
|
|
return "\n".join(lines)
|
|
|
|
## Get a single-line summary of modifiers
|
|
func get_modifiers_summary() -> String:
|
|
var modifiers = get_current_modifiers()
|
|
if modifiers.is_empty():
|
|
return "No effects"
|
|
|
|
var parts = []
|
|
for key in modifiers.keys():
|
|
var display_name = key.replace("_modifier", "").replace("_", " ").capitalize()
|
|
var percentage = _modifier_to_percentage(modifiers[key])
|
|
parts.append("%s %s" % [display_name, percentage])
|
|
|
|
return ", ".join(parts)
|
|
|
|
## Check if the unlock can be purchased/ranked up
|
|
func can_rank_up() -> bool:
|
|
# Non-scaling: can only unlock once
|
|
if not is_scaling:
|
|
return not is_unlocked
|
|
|
|
# Scaling: check if we haven't hit max rank
|
|
if max_rank > 0 and current_rank >= max_rank:
|
|
return false
|
|
|
|
return true
|
|
|
|
## Check if this is a one-off unlock (non-scaling)
|
|
func is_one_off() -> bool:
|
|
return not is_scaling
|
|
|
|
## Check if max rank has been reached (for scaling unlocks)
|
|
func is_max_rank() -> bool:
|
|
if not is_scaling:
|
|
return is_unlocked
|
|
|
|
if max_rank <= 0: # Infinite scaling
|
|
return false
|
|
|
|
return current_rank >= max_rank
|
|
|
|
## Unlock or rank up the unlock
|
|
func unlock() -> bool:
|
|
if not can_rank_up():
|
|
return false
|
|
|
|
if not is_scaling:
|
|
# Simple one-off unlock
|
|
is_unlocked = true
|
|
current_rank = 1
|
|
else:
|
|
# Scaling unlock - increase rank
|
|
current_rank += 1
|
|
is_unlocked = true
|
|
|
|
return true
|
|
|
|
## Get the next rank number (for display purposes)
|
|
func get_next_rank() -> int:
|
|
if not is_scaling:
|
|
return 1 if not is_unlocked else 1
|
|
return current_rank + 1
|
|
|
|
## Get display text for current status
|
|
func get_rank_display() -> String:
|
|
if not is_scaling:
|
|
return "Unlocked" if is_unlocked else "Locked"
|
|
|
|
if max_rank > 0:
|
|
return "Rank %d/%d" % [current_rank, max_rank]
|
|
else:
|
|
return "Rank %d" % current_rank |