Godot 4: प्रॉम्प्ट में सिग्नल नियम लिखें, MCP HP बार जोड़े

Godot में सबसे आम «AI ने तोड़ दिया» विफलता सिंटैक्स त्रुटि नहीं — यह HP बार स्क्रिप्ट में हार्ड-कोडेड पथ है:

$"/root/Game/Player/HitPoints".hp  # या get_node("../../Player/...")

ट्री दोबारा व्यवस्थित करें या Player को चाइल्ड सीन बनाएं, वह पथ मर जाता है। Godot MCP आपके प्रॉम्प्ट का पालन करता है — यदि हार्ड पथ निषिद्ध न करें, मॉडल बनाता रहेगा।

यह लेख एक काम करता है: Cursor (या Claude Code) में पहले सिग्नल अनुबंध बताएं, फिर MCP से प्लेयर HP को HUD बार से जोड़वाएं। इंस्टॉल या पूरा प्लेटफ़ॉर्मर नहीं।

चरण	क्या करें
1	सिग्नल नाम, आर्ग्युमेंट, कौन भेजे / कौन ले
2	MCP को बाधाओं वाले प्रॉम्प्ट से स्क्रिप्ट और कनेक्शन बदलवाएं
3	Play में स्वीकार करें; एंटी-पैटर्न से प्रॉम्प्ट ठीक करें

संबंधित:

• Godot MCP इंस्टॉल
• Godot MCP बनाम मैनुअल स्क्रिप्टिंग: AI को एडिटर कब सौंपें
• Godot MCP से 2D प्लेटफ़ॉर्मर

आधिकारिक संदर्भ: Scene organization — चाइल्ड सीन सिग्नल / एक्सपोर्ट से बाहर दिखाएं, गहरे पथ नहीं।

प्रॉम्प्ट में सिग्नल नियम क्यों

तरीका	अल्पकाल	पुनर्गठन के बाद
get_node("../Player/Health")	तेज़	अक्सर टूटता
@onready var bar = %HealthBar (यूनिक नाम)	एक सीन में ठीक	सीनों के बीच नाज़ुक
signal health_changed(current, max) + connect	दो अतिरिक्त पंक्तियाँ	HUD और Player अलग ट्री बदल सकते हैं

MCP में स्थायी «आर्किटेक्चर मेमोरी» नहीं जब तक बाधाएँ दोहराएँ। चिपकाने योग्य अनुबंध ब्लॉक हर diff से हार्ड पथ साफ़ करने से सस्ता है।

न्यूनतम नोड कंकाल

पूरा UI ज़रूरी नहीं। v1 के लिए बस:

Game (Node2D / Node)
├── Player (CharacterBody2D)  ← player_health.gd
│   └── ...
└── HUD (CanvasLayer)
    └── HealthBar (ProgressBar या TextureProgressBar)  ← hud_health.gd

नामकरण:

नोड	सुझावित नाम	नोट्स
प्लेयर रूट	Player	HP स्क्रिप्ट
HUD परत	HUD	CanvasLayer
बार	HealthBar	ProgressBar; पूर्ण HP या max_value = 1 अनुपात

HUD AI Studio से आया हो तो वायरिंग से पहले स्थिर अंग्रेज़ी ID पर नाम बदलें।

सिग्नल अनुबंध (हर प्रॉम्प्ट की शुरुआत में चिपकाएँ)

इसे प्रोजेक्ट नियम मानें और निर्देश की शुरुआत में चिपकाएँ:

【सिग्नल अनुबंध — HP】
1. केवल Player पर HP स्क्रिप्ट भेजे:
   signal health_changed(current: float, max_health: float)
   भूतकाल / पूर्ण नामकरण; आर्ग्युमेंट हमेशा (current, max_health)।
2. HUD बार स्क्रिप्ट केवल उस सिग्नल से जुड़े और ProgressBar अपडेट करे; HUD से Player पर get_node निषिद्ध।
3. निषिद्ध: सीनों के बीच गहरे NodePath, Autoload HP बस के रूप में (यहाँ ज़रूरी नहीं), _process में Player पोलिंग।
4. प्राथमिकता: एडिटर सिग्नल कनेक्शन, या HUD पर @export NodePath / एक्सपोर्ट Node से Player इंगित करके .connect; "/root/..." हार्डकोड न करें।
5. नुकसान और हील केवल Player पर मान बदलें और emit; UI HP न बदले।

यह ब्लॉक लेख का मूल है: कार्यान्वयन से पहले अनुबंध।

चरण 1: केवल-पढ़ने वाला स्मोक टेस्ट (MCP सीन देखे)

वर्तमान संपादित सीन के रूट के तुरंत बच्चों के नाम सूचीबद्ध करें। कोई फ़ाइल या नोड न बदलें।

Player और HUD (या समकक्ष) दिखने के बाद ही लिखें।

चरण 2: MCP Player पर «केवल emit» लागू करे

प्रॉम्प्ट उदाहरण (अनुबंध के बाद):

【सिग्नल अनुबंध — HP】（ऊपर पूरा ब्लॉक चिपकाएँ）

res://scripts/player_health.gd (न हो तो बनाएँ) और Player से जोड़ें:
- @export var max_health: float = 100.0
- var current: float
- signal health_changed(current: float, max_health: float)
- _ready में: current = max_health; एक बार health_changed emit
- take_damage(amount), heal(amount); 0..max_health में क्लैंप; हर बदलाव के बाद emit
- HUD का संदर्भ न दें; UI में get_node न करें
सहेजें और सिग्नल आर्ग्युमेंट प्रकार बताएं।

संदर्भ कार्यान्वयन (मॉडल जनरेट के बाद समीक्षा):

extends Node
class_name PlayerHealth

signal health_changed(current: float, max_health: float)

@export var max_health: float = 100.0
var current: float

func _ready() -> void:
	current = max_health
	health_changed.emit(current, max_health)

func take_damage(amount: float) -> void:
	if amount <= 0.0 or current <= 0.0:
		return
	current = maxf(0.0, current - amount)
	health_changed.emit(current, max_health)

func heal(amount: float) -> void:
	if amount <= 0.0 or current <= 0.0:
		return
	current = minf(max_health, current + amount)
	health_changed.emit(current, max_health)

अस्थायी नुकसान कुंजी (बाद में हटाएँ):

Player पर अस्थायी debug_damage.gd जोड़ें: H दबाने पर उसी नोड (या पैरेंट) पर PlayerHealth.take_damage(10)। केवल वायरिंग स्वीकृति। HUD न छुएँ।

स्क्रिप्ट Player रूट पर हो तो extends Node को रूट प्रकार से मिलाएँ (जैसे CharacterBody2D), या PlayerHealth को चाइल्ड Health बनाएँ — प्रॉम्प्ट में एक चुनें ताकि MCP माउंट बिंदु न अनुमान लगाए।

चरण 3: HUD केवल सब्सक्राइब करे, एक्सपोर्ट से Player खोजे

【सिग्नल अनुबंध — HP】（पूरा ब्लॉक）

res://scripts/hud_health.gd HUD या HealthBar पर बनाएँ:
- @export var player_health: PlayerHealth   # या Node, फिर as PlayerHealth
- @onready var bar: ProgressBar = $HealthBar  # यदि स्क्रिप्ट HUD पर; पथ केवल HUD सबट्री के भीतर
- _ready: assert player_health != null; player_health.health_changed.connect(_on_health_changed)
- _on_health_changed(current, max_health): bar.max_value = max_health; bar.value = current
  (केवल 0..1 अनुपात: bar.max_value = 1; bar.value = current / max_health)
- Player पर get_node निषिद्ध; /root पूर्ण पथ निषिद्ध
फिर: एडिटर में एक्सपोर्ट player_health को Player के PlayerHealth (या Health चाइल्ड) पर असाइन करें। सीन सहेजें।

संदर्भ:

extends CanvasLayer

@export var player_health: PlayerHealth
@onready var bar: ProgressBar = $HealthBar

func _ready() -> void:
	assert(player_health != null, "Assign PlayerHealth in the inspector")
	player_health.health_changed.connect(_on_health_changed)

func _on_health_changed(current: float, max_health: float) -> void:
	bar.max_value = max_health
	bar.value = current

HUD अंदर $HealthBar ठीक है — वही सबट्री। निषिद्ध है Player तक पार गहरा पथ।

एडिटर «नोड → सिग्नल कनेक्ट करें» MCP से भी:

एडिटर से कनेक्ट करें: Player (PlayerHealth) health_changed → HUD स्क्रिप्ट _on_health_changed। NodePath स्ट्रिंग हाथ से न लिखें।

चरण 4: Play स्वीकृति चेकलिस्ट

1. प्रवेश पर: बार भरा (या सही अनुपात)
2. H दबाएँ: bar.value गिरे
3. 0 पर: बार खाली; UI current न लिखे
4. heal के बाद: बार बढ़े
5. Player को गहरे चाइल्ड (जैसे Entities) में reparent करके फिर Play: एक्सपोर्ट रेफ़ बचा तो बार अपडेट हो — हार्ड पथ पर मुख्य लाभ

reparent के बाद टूटे तो खाली एक्सपोर्ट ठीक करें — MCP से «एक और get_node» न माँगें।

स्वीकृति प्रॉम्प्ट:

Play त्रुटियों से निदान: सिग्नल न चले तो connect जाँचें; player_health null हो तो केवल एक्सपोर्ट ठीक करें। पूर्ण get_node से «ठीक» न करें। पहले निदान; संपादन से पहले मेरी OK का इंतज़ार।

एंटी-पैटर्न: प्रॉम्प्ट बदलें, मर्ज न करें

एंटी-पैटर्न	समस्या	प्रॉम्प्ट में जोड़ें
get_node("/root/Game/Player")	रूट बदलने पर टूटता	«/root और पूर्ण NodePath निषिद्ध»
get_parent().get_node("Player")	भाई-बहन पर निर्भरता	«HUD Player की सापेक्ष लेयआउट न माने»
Autoload GlobalHealth.hp	वैश्विक कचरा	«इस कार्य के लिए नया Autoload निषिद्ध»
HUD _process में हर फ्रेम Player खोजे	धीमा और नाज़ुक	«पोलिंग नहीं; केवल सिग्नल»
सिग्नल update / set_hp	अस्पष्ट, टकराव	«सिग्नल नाम health_changed हो»

हॉट-पाथ मूवमेंट और जटिल कॉम्बैट के लिए हाथ से लिखना अभी भी बेहतर; HP बार वायरिंग बॉयलरप्लेट है जहाँ अनुबंध वाला MCP प्रॉम्प्ट आमतौर पर सस्ता। देखें Godot MCP बनाम मैनुअल स्क्रिप्टिंग।

पुन:प्रयोज्य «अनुबंध + कार्य» प्रॉम्प्ट कंकाल

माना / बॉस बार के लिए केवल सिग्नल और नोड नाम बदलें:

【सिग्नल अनुबंध】
- प्रेषक: <नोड/स्क्रिप्ट>
- signal <name>(...)
- प्राप्तकर्ता: <HUD स्क्रिप्ट विधि>
- निषिद्ध: पूर्ण NodePath, Autoload बस, _process पोलिंग

【कार्य】
1. …
2. …
3. सीन सहेजें; नए सिग्नल और कनेक्शन तरीका सूचीबद्ध करें (एडिटर / .connect)

सारांश

1. हार्ड पथ प्रॉम्प्ट छेद है, «MCP Godot नहीं जानता» नहीं
2. संपादन से पहले health_changed(current, max_health) अनुबंध चिपकाएँ
3. Player केवल emit; HUD केवल connect और ProgressBar अपडेट
4. ऑब्जेक्टों के बीच @export या एडिटर सिग्नल — /root/... नहीं
5. स्वीकृति: Player reparent करके बार देखें — «स्क्रिप्ट जनरेट OK» नहीं

अब आपके पास चिपकाने योग्य Godot MCP प्रॉम्प्ट नियम हैं; इन्वेंटरी, क्वेस्ट लॉग और किल काउंटर उसी पैटर्न से बढ़ाएँ।