@jarrodmedrano/claude-skills 1.0.2 → 1.0.4

package/.claude/skills/godot/assets/templates/attribute_template.gd

@@ -0,0 +1,109 @@
+extends Node
+class_name AttributeTemplate
+
+## Base attribute system for managing numeric values with min/max constraints.
+##
+## Usage:
+## 1. Attach to character/object as child node
+## 2. Set value_max and value_start in Inspector
+## 3. Connect to signals in parent script
+## 4. Call add()/subtract() to modify value
+##
+## Example:
+##   var health = $HealthAttribute
+##   health.attribute_changed.connect(_on_health_changed)
+##   health.subtract(10.0)  # Take 10 damage
+
+# Signals
+signal attribute_changed(attribute_name: String, value_current: float, value_max: float, value_increased: bool)
+signal attribute_reached_zero(attribute_name: String)
+signal attribute_reached_max(attribute_name: String)
+
+# Configuration
+@export_group("Attribute Settings")
+@export var attribute_name: String = "Attribute"
+@export var value_max: float = 100.0
+@export var value_start: float = 100.0
+
+@export_group("Regeneration")
+@export var auto_regenerate: bool = false
+@export var regen_rate: float = 1.0  # Per second
+@export var regen_delay: float = 3.0  # Delay after damage
+
+# Current value with automatic clamping and signal emission
+var value_current: float:
+	set(value):
+		var old_value = value_current
+		value_current = clamp(value, 0, value_max)
+		var increased = value_current > old_value
+
+		attribute_changed.emit(attribute_name, value_current, value_max, increased)
+
+		if value_current <= 0:
+			attribute_reached_zero.emit(attribute_name)
+		elif value_current >= value_max and old_value < value_max:
+			attribute_reached_max.emit(attribute_name)
+
+# Internal state for regeneration
+var _regen_timer: float = 0.0
+
+## Initialize the attribute
+func _ready() -> void:
+	value_current = value_start
+	print("[", attribute_name, "] Initialized: ", value_current, "/", value_max)
+
+## Handle regeneration
+func _process(delta: float) -> void:
+	if not auto_regenerate:
+		return
+
+	if value_current >= value_max:
+		_regen_timer = 0.0
+		return
+
+	_regen_timer += delta
+	if _regen_timer >= regen_delay:
+		add(regen_rate * delta)
+
+## Add to the attribute value
+func add(amount: float) -> void:
+	if amount <= 0:
+		return
+	value_current += amount
+
+## Subtract from the attribute value
+func subtract(amount: float) -> void:
+	if amount <= 0:
+		return
+	value_current -= amount
+	_regen_timer = 0.0  # Reset regen timer on damage
+
+## Set to a specific value
+func set_value(new_value: float) -> void:
+	value_current = new_value
+
+## Set to maximum
+func set_to_max() -> void:
+	value_current = value_max
+
+## Set to zero
+func set_to_zero() -> void:
+	value_current = 0.0
+
+## Get current percentage (0.0 to 1.0)
+func get_percentage() -> float:
+	if value_max <= 0:
+		return 0.0
+	return value_current / value_max
+
+## Check if attribute is depleted
+func is_depleted() -> bool:
+	return value_current <= 0
+
+## Check if attribute is full
+func is_full() -> bool:
+	return value_current >= value_max
+
+## Get remaining value
+func get_remaining() -> float:
+	return value_max - value_current

package/.claude/skills/godot/assets/templates/component_template.gd

@@ -0,0 +1,76 @@
+extends Node
+class_name ComponentTemplate
+
+## A reusable component template following Godot best practices.
+##
+## Usage:
+## 1. Attach as child node to the object that needs this functionality
+## 2. Export variables appear in Inspector for easy configuration
+## 3. Use signals for loose coupling with parent/other systems
+
+# Signals for event-driven communication
+signal component_activated
+signal component_deactivated
+signal component_updated(data: Dictionary)
+
+# Export variables for Inspector configuration
+@export_group("Component Settings")
+@export var is_enabled: bool = true
+@export var auto_start: bool = true
+
+@export_group("Behavior")
+@export var update_interval: float = 1.0
+
+# Internal state
+var _timer: float = 0.0
+var _is_active: bool = false
+
+## Called when the node enters the scene tree
+func _ready() -> void:
+	if auto_start:
+		activate()
+
+## Called every frame
+func _process(delta: float) -> void:
+	if not _is_active or not is_enabled:
+		return
+
+	_timer += delta
+	if _timer >= update_interval:
+		_update()
+		_timer = 0.0
+
+## Activate the component
+func activate() -> void:
+	if _is_active:
+		return
+
+	_is_active = true
+	component_activated.emit()
+	print("[", name, "] Component activated")
+
+## Deactivate the component
+func deactivate() -> void:
+	if not _is_active:
+		return
+
+	_is_active = false
+	component_deactivated.emit()
+	print("[", name, "] Component deactivated")
+
+## Internal update logic - override in subclasses
+func _update() -> void:
+	var data = {
+		"timestamp": Time.get_ticks_msec(),
+		"component": name
+	}
+	component_updated.emit(data)
+
+## Public interface for parent to call
+func do_something() -> void:
+	if not is_enabled:
+		push_warning("Component not enabled")
+		return
+
+	# Implementation here
+	pass

package/.claude/skills/godot/assets/templates/interaction_template.gd

@@ -0,0 +1,108 @@
+extends Node
+class_name InteractionTemplate
+
+## Base class for interaction components following the component pattern.
+##
+## Usage:
+## 1. Create subclass extending InteractionTemplate
+## 2. Override _perform_interaction() with custom logic
+## 3. Attach as child to BaseInteractable object
+## 4. Set interaction_text and other exports in Inspector
+##
+## Example subclass:
+##   extends InteractionTemplate
+##   class_name DoorInteraction
+##
+##   @export var door_id: String
+##   @export var requires_key: bool = false
+##
+##   func _perform_interaction(player) -> void:
+##       if requires_key and not player.has_key(door_id):
+##           return
+##       get_parent().open()
+
+# Signals
+signal was_interacted_with(player: Node)
+signal interaction_enabled
+signal interaction_disabled
+
+# Configuration
+@export_group("Interaction Settings")
+@export var interaction_text: String = "Interact"
+@export var is_enabled: bool = true
+@export var single_use: bool = false
+
+@export_group("Requirements")
+@export var required_item_id: String = ""
+@export var minimum_level: int = 0
+
+# Internal state
+var _has_been_used: bool = false
+
+## Attempt to interact with this component
+## Returns true if interaction was successful
+func interact(player: Node) -> bool:
+	if not can_interact(player):
+		return false
+
+	_perform_interaction(player)
+	was_interacted_with.emit(player)
+
+	if single_use:
+		_has_been_used = true
+		disable()
+
+	return true
+
+## Check if interaction is possible
+func can_interact(player: Node) -> bool:
+	if not is_enabled:
+		return false
+
+	if single_use and _has_been_used:
+		return false
+
+	if required_item_id and not _player_has_item(player, required_item_id):
+		return false
+
+	if minimum_level > 0 and not _player_meets_level(player, minimum_level):
+		return false
+
+	return true
+
+## Get the text to display for this interaction
+func get_interaction_text() -> String:
+	return interaction_text
+
+## Enable this interaction
+func enable() -> void:
+	is_enabled = true
+	interaction_enabled.emit()
+
+## Disable this interaction
+func disable() -> void:
+	is_enabled = false
+	interaction_disabled.emit()
+
+## Reset for reuse (if not single_use)
+func reset() -> void:
+	if not single_use:
+		_has_been_used = false
+		enable()
+
+## OVERRIDE THIS: Perform the actual interaction logic
+func _perform_interaction(player: Node) -> void:
+	print("[", get_parent().name, "] Interacted by ", player.name)
+	# Override in subclasses with specific interaction logic
+
+## Helper: Check if player has required item
+func _player_has_item(player: Node, item_id: String) -> bool:
+	if not player.has_method("has_item"):
+		return false
+	return player.has_item(item_id)
+
+## Helper: Check if player meets level requirement
+func _player_meets_level(player: Node, level: int) -> bool:
+	if not player.has_method("get_level"):
+		return false
+	return player.get_level() >= level

package/.claude/skills/godot/assets/templates/item_resource.tres

@@ -0,0 +1,11 @@
+[gd_resource type="Resource" script_class="ItemResource" load_steps=2 format=3 uid="uid://template_item"]
+
+[ext_resource type="Script" path="res://src/items/item_resource.gd" id="1_item"]
+
+[resource]
+script = ExtResource("1_item")
+item_id = "example_item"
+item_name = "Example Item"
+description = "A template item resource"
+stackable = true
+max_stack = 99

package/.claude/skills/godot/assets/templates/spell_resource.tres

@@ -0,0 +1,20 @@
+[gd_resource type="Resource" script_class="SpellResource" load_steps=3 format=3 uid="uid://template_spell"]
+
+[ext_resource type="Script" path="res://src/spells/spell_resource.gd" id="1_spell"]
+[ext_resource type="Script" path="res://src/spells/spell_effect.gd" id="2_effect"]
+
+[sub_resource type="Resource" id="Effect_damage"]
+script = ExtResource("2_effect")
+effect_type = 0
+magnitude_min = 10.0
+magnitude_max = 20.0
+duration = 0.0
+
+[resource]
+script = ExtResource("1_spell")
+spell_name = "Magic Missile"
+spell_id = "magic_missile"
+mana_cost = 15.0
+spell_color = Color(0.5, 0.5, 1, 1)
+projectile_speed = 20.0
+effects = Array[ExtResource("2_effect")]([SubResource("Effect_damage")])