समजा आपल्याकडे एक ऑब्जेक्ट आहे ज्याला बिंदूकडे जाण्याची आवश्यकता आहे. कार्य सोपे आहे, उदाहरणार्थ, इंटरपोलेशन वापरा. पण आपली वस्तू यादृच्छिक कोनात फिरू शकते तर? मग इंटरपोलेशनसाठी बिंदू कसा सेट करायचा? आपली पारंपारिक ट्रॉली फक्त चाकांच्या दिशेनेच फिरली पाहिजे. त्यानुसार, एकतर मागे किंवा पुढची बाजू. सदिश बीजगणित आम्हाला या समस्येचे निराकरण करण्यात मदत करेल.

सिद्धांत

सदिश बीजगणित वापरणे हे सत्य आपण स्वीकारले आहे हे कार्यसोडवण्यायोग्य याचा अर्थ आपल्याला वेक्टरसह काहीतरी करण्याची आवश्यकता आहे. पण काय? प्रथम, आपल्या समस्येवर वेक्टरची संकल्पना प्रक्षेपित करू. समस्येच्या परिस्थितीनुसार, आम्हाला इंटरपोलेशनसाठी एक बिंदू निर्दिष्ट करणे आवश्यक आहे. म्हणजेच, जागतिक/स्थानिक समन्वय प्रणालीशी संबंधित बिंदू ज्याकडे ऑब्जेक्ट नंतर हलवेल. याचा अर्थ असा की आपण हालचाली निर्दिष्ट करण्यासाठी घेतलेल्या ऑब्जेक्टचा बिंदू आणि अंतिम इच्छित बिंदू दरम्यानचा विभाग एक सदिश असेल.

आता आपल्याला माहित आहे की आपल्याकडे वेक्टर आहे आणि आपल्याला त्याच्या टोकाचे निर्देशांक शोधण्याची आवश्यकता आहे. या समस्येचे निःसंदिग्धपणे निराकरण करण्यासाठी, पॅरामीटर्सचा संच आवश्यक आहे:

• वेक्टर मूळ निर्देशांक;
• वेक्टर लांबी;
• समन्वय अक्षांकडे झुकण्याचा कोन.

हे सर्व माहीत आहे असे मानू या. मग समस्या साइन प्रमेयच्या सर्वात सोप्या सूत्रांमध्ये कमी केली जाते.

$inline$x/sin(α) = a/sin (90)$inline$
$inline$ x = a* sin(α)$inline$
$inline$y/sin (90 - α) = a/sin(90)$inline$
$inline$ y = a * sin (90 - α)$inline$

जेथे a ही सदिशाची लांबी आहे, α हा समन्वय अक्षाकडे झुकण्याचा कोन आहे

वास्तविक, हे ज्ञान आपल्यासाठी व्यवहारात समस्या सोडवण्यासाठी पुरेसे आहे.

सराव

तर आम्हाला माहित आहे:

• ऑब्जेक्टच्या पुढील आणि मागील बाजू कुठे आहेत;
• ऑब्जेक्टची वर्तमान स्थिती;
• कोन ज्याद्वारे ऑब्जेक्ट फिरला आहे.
• एखाद्या वस्तूने प्रवास करणे आवश्यक आहे.

आमच्याकडे जवळजवळ सर्व माहिती आहे, परंतु आमच्या प्रकरणानुसार, आम्हाला अंकीयदृष्ट्या वस्तूच्या फिरण्याचे कोन माहित आहे, परंतु ते कोणत्या अक्षावर वळले हे आम्हाला माहित नाही. अतिरिक्त डेटा आवश्यक आहे. मग आम्ही एक चतुर्थांश संकल्पना सादर करतो. हे रहस्य नाही की द्विमितीय कार्टेशियन समन्वय प्रणालीमध्ये अनुक्रमे 1 ते 4 पर्यंत 4 चतुर्थांश असतात. प्रत्येक तिमाहीत धुरा असतात भिन्न चिन्हे.

आणि हे एकात्मतेने देखील कार्य करते. प्रथम, आपल्याला दृश्यातील क्वार्टर परिभाषित करणे आवश्यक आहे. आपण उगमस्थानी एक घन तयार करतो, तो हलवू आणि कोणते समन्वय ऋणात्मक आहेत आणि कोणते सकारात्मक आहेत ते पाहू. उदाहरणामध्ये तुम्ही पाहू शकता की दोन्ही समन्वय ऋणात्मक आहेत, याचा अर्थ घन तिसऱ्या तिमाहीत आहे.

आता तुम्ही थेट स्क्रिप्टवर जाऊ शकता. इनपुट म्हणून आपण रोटेशन नंतर मूळ ऑब्जेक्टचे ट्रान्सफॉर्म घेतो आणि डमीचे ट्रान्सफॉर्म घेतो, ज्याकडे आपण पुढे जाऊ. डमीमध्ये सुरुवातीला ऑब्जेक्टचे निर्देशांक असतात. पुढे, आम्ही ऑब्जेक्टचा पुढचा भाग कोणत्या तिमाहीत स्थित आहे हे निर्धारित करतो. त्रिकोणमितीय वर्तुळ 0 ते 360 अंशांपर्यंत मर्यादित असल्याने, हे अवघड नाही. तिमाही निश्चित केल्यावर, आम्ही प्रत्येक समन्वयासाठी झुकाव कोनांची गणना करतो. मग आम्ही तपासतो की आमच्या कोनांमध्ये योग्य चिन्ह आहे. यानंतर, आम्ही कोऑर्डिनेट्सची गणना करण्यासाठी झुकणारे कोन अंतिम सूत्राकडे पाठवतो. आणि शेवटी, आम्ही डमीसाठी नवीन समन्वय सेट करतो ज्यामध्ये आम्ही इंटरपोलेट करू.

Void CheckingQuarterUp(ट्रान्सफॉर्म व्हेक्टर अँगल, रेफ ट्रान्सफॉर्म रिक्त) ( फ्लोट झँगल = 0; फ्लोट xangle = 0; फ्लोट zcoord = 0.0f; फ्लोट xcoord = 0.0f; int normangle = Mathf.RoundToIntlesman (if. >= 0 && नॉर्मंगल<= 90) // 1-ая четверть { zangle = 90 - normangle; xangle = 0 - normangle; xangle = (xangle < 0) ? xangle * -1: xangle; zangle = (zangle < 0) ? zangle * -1: zangle; } if (normangle >270 && नॉर्मंगल<= 360) // 2-ая четверть { xangle = 360 - normangle; zangle = 270 - normangle; xangle = (xangle >0)? xangle * -1: xangle; zangle = (zangle< 0) ? zangle * -1: zangle; } if (normangle >180 && नॉर्मंगल<= 270) // 3-ая четверть { xangle = 180 - normangle; zangle = 270 - normangle; xangle = (xangle >0)? xangle * -1: xangle; zangle = (zangle > 0) ? zangle * -1: zangle; ) जर (सामान्य > 90 && नॉर्मंगल<= 180) // 4-ая четверть { zangle = 90 - normangle; xangle = 180 - normangle; zangle = (zangle >0)? zangle * -1: zangle; xangle = (xangle< 0) ? xangle * -1: xangle; } zcoord = path * Mathf.Sin (zangle *Mathf.PI/180); xcoord = path * Mathf.Sin (xangle * Mathf.PI/180); float newpathx = empty.position.x + xcoord; float newpathz = empty.position.z + zcoord; empty.position = new Vector3 (newpathx, empty.transform.position.y, newpathz); }

निष्कर्ष

जसे आपण पाहू शकता, उपाय अगदी सोपे आहे. वापरण्यापूर्वी ही पद्धतआपल्याकडे पुरेसा डेटा आहे की नाही ते तपासा, अन्यथा कार्य स्पष्टपणे निराकरण करण्यायोग्य होईल. उदाहरणार्थ, अक्षांकडे झुकण्याचा कोन काढून टाकल्याने, सोल्युशन क्षेत्र असीम बिंदू असलेले वर्तुळ बनते.

मागे जाण्यासाठी, तुम्हाला फक्त चतुर्थांशानुसार समन्वय चिन्हे डायमेट्रिकली बदलण्याची आवश्यकता आहे. आपण त्रिमितीय जागेत बिंदू परिभाषित करण्याचे ठरविल्यास, लक्षात ठेवा की तेथे अधिक "चतुर्थांश" असतील.

पद्धतीच्या अंमलबजावणीचे उदाहरण घेता येईल

, सँडबॉक्समधून

परिचय

समजा आपल्याकडे एक ऑब्जेक्ट आहे ज्याला बिंदूकडे जाण्याची आवश्यकता आहे. कार्य सोपे आहे, उदाहरणार्थ, इंटरपोलेशन वापरा. पण आपली वस्तू यादृच्छिक कोनात फिरू शकते तर? मग इंटरपोलेशनसाठी बिंदू कसा सेट करायचा? आपली पारंपारिक ट्रॉली फक्त चाकांच्या दिशेनेच फिरली पाहिजे. त्यानुसार, एकतर मागे किंवा पुढची बाजू. सदिश बीजगणित आम्हाला या समस्येचे निराकरण करण्यात मदत करेल.

सिद्धांत

सदिश बीजगणित वापरून ही समस्या सोडवली जाऊ शकते हे सत्य आम्ही स्वीकारले. याचा अर्थ आपल्याला वेक्टरसह काहीतरी करण्याची आवश्यकता आहे. पण काय? प्रथम, आपल्या समस्येवर वेक्टरची संकल्पना प्रक्षेपित करू. समस्येच्या परिस्थितीनुसार, आम्हाला इंटरपोलेशनसाठी एक बिंदू निर्दिष्ट करणे आवश्यक आहे. म्हणजेच, जागतिक/स्थानिक समन्वय प्रणालीशी संबंधित बिंदू ज्याकडे ऑब्जेक्ट नंतर हलवेल. याचा अर्थ असा की आपण हालचाली निर्दिष्ट करण्यासाठी घेतलेल्या ऑब्जेक्टचा बिंदू आणि अंतिम इच्छित बिंदू दरम्यानचा विभाग एक सदिश असेल.

आता आपल्याला माहित आहे की आपल्याकडे वेक्टर आहे आणि आपल्याला त्याच्या टोकाचे निर्देशांक शोधण्याची आवश्यकता आहे. या समस्येचे निःसंदिग्धपणे निराकरण करण्यासाठी, पॅरामीटर्सचा संच आवश्यक आहे:

• वेक्टर मूळ निर्देशांक;
• वेक्टर लांबी;
• समन्वय अक्षांकडे झुकण्याचा कोन.

हे सर्व माहीत आहे असे मानू या. मग समस्या साइन प्रमेयच्या सर्वात सोप्या सूत्रांमध्ये कमी केली जाते.

$inline$x/sin(?) = a/sin (90)$inline$
$inline$ x = a* sin(?)$inline$
$inline$y/sin (90 - ?) = a/sin(90)$inline$
$inline$ y = a * sin (90 - ?)$inline$

a सदिशाची लांबी कुठे आहे, ? - समन्वय अक्षाकडे झुकण्याचा कोन

वास्तविक, हे ज्ञान आपल्यासाठी व्यवहारात समस्या सोडवण्यासाठी पुरेसे आहे.

सराव

तर आम्हाला माहित आहे:

• ऑब्जेक्टच्या पुढील आणि मागील बाजू कुठे आहेत;
• ऑब्जेक्टची वर्तमान स्थिती;
• कोन ज्याद्वारे ऑब्जेक्ट फिरला आहे.
• एखाद्या वस्तूने प्रवास करणे आवश्यक आहे.

आमच्याकडे जवळजवळ सर्व माहिती आहे, परंतु आमच्या प्रकरणानुसार, आम्हाला अंकीयदृष्ट्या वस्तूच्या फिरण्याचे कोन माहित आहे, परंतु ते कोणत्या अक्षावर वळले हे आम्हाला माहित नाही. अतिरिक्त डेटा आवश्यक आहे. मग आम्ही एक चतुर्थांश संकल्पना सादर करतो. हे रहस्य नाही की द्विमितीय कार्टेशियन समन्वय प्रणालीमध्ये अनुक्रमे 1 ते 4 पर्यंत 4 चतुर्थांश असतात. प्रत्येक तिमाहीत अक्षांवर वेगवेगळी चिन्हे असतात.

आणि हे एकात्मतेने देखील कार्य करते. प्रथम, आपल्याला दृश्यातील क्वार्टर परिभाषित करणे आवश्यक आहे. आपण उगमस्थानी एक घन तयार करतो, तो हलवू आणि कोणते समन्वय ऋणात्मक आहेत आणि कोणते सकारात्मक आहेत ते पाहू. उदाहरणामध्ये तुम्ही पाहू शकता की दोन्ही समन्वय ऋणात्मक आहेत, याचा अर्थ घन तिसऱ्या तिमाहीत आहे.

आता तुम्ही थेट स्क्रिप्टवर जाऊ शकता. इनपुट म्हणून आपण रोटेशन नंतर मूळ ऑब्जेक्टचे ट्रान्सफॉर्म घेतो आणि डमीचे ट्रान्सफॉर्म घेतो, ज्याकडे आपण पुढे जाऊ. डमीमध्ये सुरुवातीला ऑब्जेक्टचे निर्देशांक असतात. पुढे, आम्ही ऑब्जेक्टचा पुढचा भाग कोणत्या तिमाहीत स्थित आहे हे निर्धारित करतो. त्रिकोणमितीय वर्तुळ 0 ते 360 अंशांपर्यंत मर्यादित असल्याने, हे अवघड नाही. तिमाही निश्चित केल्यावर, आम्ही प्रत्येक समन्वयासाठी झुकाव कोनांची गणना करतो. मग आम्ही तपासतो की आमच्या कोनांमध्ये योग्य चिन्ह आहे. यानंतर, आम्ही कोऑर्डिनेट्सची गणना करण्यासाठी झुकणारे कोन अंतिम सूत्राकडे पाठवतो. आणि शेवटी, आम्ही डमीसाठी नवीन समन्वय सेट करतो ज्यामध्ये आम्ही इंटरपोलेट करू.

Void CheckingQuarterUp(ट्रान्सफॉर्म व्हेक्टर अँगल, रेफ ट्रान्सफॉर्म रिक्त) ( फ्लोट झँगल = 0; फ्लोट xangle = 0; फ्लोट zcoord = 0.0f; फ्लोट xcoord = 0.0f; int normangle = Mathf.RoundToIntlesman (if. >= 0 && नॉर्मंगल<= 90) // 1-ая четверть { zangle = 90 - normangle; xangle = 0 - normangle; xangle = (xangle < 0) ? xangle * -1: xangle; zangle = (zangle < 0) ? zangle * -1: zangle; } if (normangle >270 && नॉर्मंगल<= 360) // 2-ая четверть { xangle = 360 - normangle; zangle = 270 - normangle; xangle = (xangle >0)? xangle * -1: xangle; zangle = (zangle< 0) ? zangle * -1: zangle; } if (normangle >180 && नॉर्मंगल<= 270) // 3-ая четверть { xangle = 180 - normangle; zangle = 270 - normangle; xangle = (xangle >0)? xangle * -1: xangle; zangle = (zangle > 0) ? zangle * -1: zangle; ) जर (सामान्य > 90 && नॉर्मंगल<= 180) // 4-ая четверть { zangle = 90 - normangle; xangle = 180 - normangle; zangle = (zangle >0)? zangle * -1: zangle; xangle = (xangle< 0) ? xangle * -1: xangle; } zcoord = path * Mathf.Sin (zangle *Mathf.PI/180); xcoord = path * Mathf.Sin (xangle * Mathf.PI/180); float newpathx = empty.position.x + xcoord; float newpathz = empty.position.z + zcoord; empty.position = new Vector3 (newpathx, empty.transform.position.y, newpathz); }

निष्कर्ष

जसे आपण पाहू शकता, उपाय अगदी सोपे आहे. ही पद्धत वापरण्यापूर्वी, आपल्याकडे पुरेसा डेटा आहे की नाही ते तपासा, अन्यथा कार्य स्पष्टपणे निराकरण करण्यायोग्य होईल. उदाहरणार्थ, अक्षांकडे झुकण्याचा कोन काढून टाकल्याने, सोल्युशन क्षेत्र असीम बिंदू असलेले वर्तुळ बनते.

मागे जाण्यासाठी, तुम्हाला फक्त चतुर्थांशानुसार समन्वय चिन्हे डायमेट्रिकली बदलण्याची आवश्यकता आहे. आपण त्रिमितीय जागेत बिंदू परिभाषित करण्याचे ठरविल्यास, लक्षात ठेवा की तेथे अधिक "चतुर्थांश" असतील.

पद्धतीच्या अंमलबजावणीचे उदाहरण घेता येईल

तर. सर्वांना नमस्कार. आणि आज मी तुम्हाला एक साधी वर्ण चळवळ कशी करावी हे सांगेन. आता फक्त तिसऱ्या व्यक्तीमध्ये... चला सुरुवात करूया...
चला एक वर्ण तयार करण्यापासून सुरुवात करूया. माझ्यासाठी ते एक घन असेल. ज्यांना क्यूब्स किंवा वर्तुळे कशी तयार करायची हे माहित नाही त्यांच्यासाठी मी समजावून सांगू - “GameObject” => “CreateOther” => “Cube”. आम्ही त्याच प्रकारे कॅमेरा तयार करतो आणि त्याला क्यूबमध्ये बांधतो (म्हणजेच, आम्ही पदानुक्रमात कॅमेरा फक्त क्यूबवर ड्रॅग करतो).
तर... आता एक पृष्ठभाग तयार करू ज्यावर पात्र चालेल. ते फक्त "विमान" असू द्या. ओह, होय... धड्याच्या शेवटी ज्यांना समजले नाही त्यांच्यासाठी ट्युटोरियलसाठी स्त्रोत कोडसह एक लिंक असेल.
तर. आता "Move" स्क्रिप्ट तयार करू. प्लेअर व्हेरिएबल आणि स्पीड व्हेरिएबल जोडू.

सार्वजनिक गेमऑब्जेक्ट प्लेयर;
सार्वजनिक इंट गती = 5;

आता स्टार्ट मेथडमध्ये सूचित करूया की ही ती ऑब्जेक्ट आहे ज्यावर स्क्रिप्ट हँग होते.

शून्य प्रारंभ() (
player = (GameObject)this.gameObject;
}

आता "W" किंवा वरचा बाण दाबून प्लेअरला पुढे हलवू. आम्ही हे void Update() पद्धतीने करतो!हे करण्यासाठी, आम्ही एक स्थान जोडू. उदाहरणार्थ, पुढे.

जर (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow))
{
}

आम्ही फॉरवर्ड पोझिशन जोडली आणि ती स्पीडने किंवा त्याऐवजी व्हेरिएबलने गुणाकार केली. आणि फ्रेम्स प्रति सेकंद (डेल्टाटाइम) ने गुणाकार करण्याचे सुनिश्चित करा.
चला त्याच प्रकारे मागे जाऊया. आम्ही फक्त पद काढून घेऊ.

जर (Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.DownArrow))
{
player.transform.position -= player.transform.forward * speed * Time.deltaTime;
}

त्याच प्रकारे आपण उजवीकडे आणि डावीकडे (उजवीकडे, डावीकडे) दोन्ही करू शकतो, परंतु “A” किंवा “D” दाबताना मी फक्त प्लेअर फिरवीन.
मी "Rotate()" वापरेन. "Y" अक्षावर फिरण्यासाठी, मी "वर" आणि "खाली" वापरेन. तसे, यासाठी तुम्हाला “पब्लिक इंट स्पीड रोटेशन = 3” व्हेरिएबल देखील घोषित करावे लागेल. आणि आम्ही परिस्थितीनुसार लिहितो.

जर (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow))
{
player.transform.Rotate(Vector3.down * speedRotation);
}
if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
{
player.transform.Rotate(Vector3.up * speedRotation);
}

बरं... आता ॲनिमेट करण्याची वेळ आली आहे. मी युनिटीमध्येच ॲनिमेशन रेकॉर्ड करतो. हे "विंडो" => "ॲनिमेशन" मध्ये उघडता येते. या विंडोमध्ये आपण क्यूब ॲनिमेट करू शकतो. तर... चला ॲनिमेशन तयार करण्याचा क्षण वगळूया. आता ॲनिमेशन व्हेरिएबल बनवू.

सार्वजनिक ॲनिमेशनक्लिप ॲनिमा;

आता सुरुवातीला एक क्लिप जोडू.

Animation.AddClip(anima, "animCube");

आता आम्ही ते "क्रॉसफेड" च्या माध्यमातून खेळू. पुढे आणि मागे चालताना मी त्याचे पुनरुत्पादन करीन. पुनरुत्पादन करण्यासाठी, आपल्याला लिहावे लागेल.

तर... आम्ही ते केले चांगला कोड. आता आपण झेप घेऊ. हे अगदी सोपे आहे. पुन्हा आपण स्थान जोडू. फक्त वर.
आणि तेच नवीन ॲनिमेशन व्हेरिएबल "पब्लिक ॲनिमेशनक्लिप ॲनिमा2;"? चला "public int jumpSpeed ​​= 50;" व्हेरिएबल देखील जोडूया. आणि आम्हाला अट मिळते.

जर (Input.GetKeyDown(KeyCode.Space))
{
player.transform.position += player.transform.up * jumpSpeed ​​* Time.deltaTime;
}

बस्स... आमचा कोड तयार आहे.

UnityEngine वापरून;
System.Collections वापरून;
सार्वजनिक वर्ग हलवा: MonoBehaviour (
सार्वजनिक गेमऑब्जेक्ट प्लेयर;
public int speedRotation = 3;
सार्वजनिक इंट गती = 5;
सार्वजनिक ॲनिमेशनक्लिप ॲनिमा;
सार्वजनिक इंट जंपस्पीड = 50;

शून्य प्रारंभ() (
player = (GameObject)this.gameObject;
animation.AddClip(anima, "animCube");
}
शून्य अद्यतन()
if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow))
{
player.transform.position += player.transform.forward * speed * Time.deltaTime;
animation.CrossFade("animCube");
}
if (Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.DownArrow))
{
player.transform.position -= player.transform.forward * speed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow))
{
player.transform.Rotate(Vector3.down * speedRotation);
}
if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
{
player.transform.Rotate(Vector3.up * speedRotation);
}
जर (Input.GetKeyDown(KeyCode.Space))
{
player.transform.position += player.transform.up * jumpSpeed ​​* Time.deltaTime;
}

कार्यक्रम कार्ये

घटक वापरून गेमऑब्जेक्ट्स व्यवस्थापित करणे

IN एकता संपादकइन्स्पेक्टर विंडो वापरून तुम्ही घटकाचे गुणधर्म बदलता. तर, उदाहरणार्थ, ट्रान्सफॉर्म घटकाची स्थिती बदलल्याने गेम ऑब्जेक्टची स्थिती बदलेल. त्याचप्रमाणे, तुम्ही गेम ऑब्जेक्टच्या डिस्प्ले किंवा वर्तनावर संबंधित प्रभावांसह रेंडरर घटकाच्या सामग्रीचा रंग किंवा RigidBody चे वस्तुमान बदलू शकता. बहुतांश भागांसाठी, स्क्रिप्ट्स गेम ऑब्जेक्ट्स व्यवस्थापित करण्यासाठी घटकांचे गुणधर्म देखील बदलतात. तथापि, फरक हा आहे की स्क्रिप्ट कालांतराने किंवा वापरकर्त्याकडून इनपुट मिळाल्यावर मालमत्तेचे मूल्य हळूहळू बदलू शकते. मध्ये वस्तू बदलून, तयार करून आणि नष्ट करून निर्दिष्ट वेळकोणताही गेमप्ले लागू केला जाऊ शकतो.

घटकांमध्ये प्रवेश करणे

जेव्हा स्क्रिप्टला त्याच GameObject शी संलग्न इतर घटकांमध्ये प्रवेश करण्याची आवश्यकता असते तेव्हा सर्वात सोपी आणि सामान्य केस असते. परिचय विभागात नमूद केल्याप्रमाणे, घटक हा प्रत्यक्षात वर्गाचा एक उदाहरण आहे, म्हणून पहिली पायरी म्हणजे आपण ज्या घटकासह कार्य करू इच्छिता त्या घटकाच्या उदाहरणाचा संदर्भ प्राप्त करणे. हे GetComponent फंक्शन वापरून केले जाते. सामान्यतः, एक घटक ऑब्जेक्ट व्हेरिएबलमध्ये संग्रहित केला जातो, हे खालील वाक्यरचना वापरून C# मध्ये केले जाते:

(); }

युनिटीस्क्रिप्टमध्ये वाक्यरचना थोडी वेगळी आहे:

फंक्शन स्टार्ट() (var rb = GetComponent. (); }

Void Start() (Rigidbody rb = GetComponent (); // ऑब्जेक्टच्या Rigidbody चे वस्तुमान बदला rb.mass = 10f;

इन्स्पेक्टर विंडोमध्ये उपलब्ध नसलेले अतिरिक्त वैशिष्ट्य घटक उदाहरणाच्या फंक्शन्सला कॉल करत आहे:

Void Start() (Rigidbody rb = GetComponent (); // रिजिडबॉडीमध्ये एक शक्ती जोडा. rb.AddForce(Vector3.up * 10f); )

लक्षात ठेवा की तुम्ही एकाच ऑब्जेक्टशी एकापेक्षा जास्त सानुकूल स्क्रिप्ट संलग्न करू शकत नाही असे कोणतेही कारण नाही. तुम्हाला एका स्क्रिप्टमधून दुसऱ्या स्क्रिप्टमध्ये प्रवेश करण्याची आवश्यकता असल्यास, तुम्हाला कोणत्या प्रकारचा घटक हवा आहे हे निर्दिष्ट करण्यासाठी स्क्रिप्टचे वर्ग नाव (किंवा फाइल नाव) वापरून तुम्ही नेहमीप्रमाणे GetComponent वापरू शकता.

तुम्ही गेम ऑब्जेक्टमध्ये न जोडलेला घटक पुनर्प्राप्त करण्याचा प्रयत्न केल्यास, GetComponent शून्य परत येईल; तुम्ही रिकाम्या ऑब्जेक्टवर कोणतीही मूल्ये बदलण्याचा प्रयत्न केल्यास रनटाइमवर एक शून्य संदर्भ त्रुटी येईल.

इतर वस्तूंचा संदर्भ देत

जरी ते कधीकधी अलगावमध्ये अस्तित्वात असले तरी, स्क्रिप्ट सहसा इतर वस्तूंचा मागोवा घेतात. उदाहरणार्थ, पाठलाग करणाऱ्या शत्रूला खेळाडूची स्थिती माहित असणे आवश्यक आहे. युनिटी इतर वस्तू मिळविण्याचे अनेक मार्ग प्रदान करते, प्रत्येक विशिष्ट परिस्थितीसाठी अनुकूल आहे.

व्हेरिएबल्सद्वारे ऑब्जेक्ट्स जोडणे

इच्छित गेम ऑब्जेक्ट शोधण्याचा सर्वात सोपा मार्ग म्हणजे तो स्क्रिप्टमध्ये जोडणे व्हेरिएबल टाइप करासार्वजनिक प्रवेश स्तरासह गेमऑब्जेक्ट:

सार्वजनिक वर्ग शत्रू: मोनोबिहेविअर ( सार्वजनिक गेमऑब्जेक्ट प्लेयर; // इतर व्हेरिएबल्स आणि फंक्शन्स...)

व्हेरिएबल इतर कोणत्याहीप्रमाणे इन्स्पेक्टर विंडोमध्ये दृश्यमान असेल:

तुम्ही आता दृश्य किंवा पदानुक्रम पॅनेलमधून एखादी वस्तू नियुक्त करण्यासाठी या व्हेरिएबलवर ड्रॅग करू शकता. GetComponent फंक्शन आणि घटक व्हेरिएबल्समध्ये प्रवेश या ऑब्जेक्ट आणि इतर दोन्हीसाठी उपलब्ध आहे, म्हणजे तुम्ही खालील कोड वापरू शकता:

सार्वजनिक वर्ग शत्रू: MonoBehaviour ( सार्वजनिक गेमऑब्जेक्ट प्लेअर; void Start() ( // शत्रूला प्लेअर कॅरेक्टरच्या मागे दहा युनिट सुरू करा. transform.position = player.transform.position - Vector3.forward * 10f; ) )

तसेच, जर तुम्ही व्हेरिएबल घोषित केले तर सार्वजनिक प्रवेशआणि तुमच्या स्क्रिप्टमधील घटक प्रकार दिल्यास, तुम्ही त्या प्रकाराचा संलग्न घटक असलेली कोणतीही वस्तू ड्रॅग करू शकाल. हे गेम ऑब्जेक्टच्या ऐवजी थेट घटकामध्ये प्रवेश करण्यास अनुमती देईल.

सार्वजनिक ट्रान्सफॉर्म प्लेयर ट्रान्सफॉर्म;

व्हेरिएबल्सद्वारे ऑब्जेक्ट्स कनेक्ट करणे सर्वात उपयुक्त आहे जेव्हा आपण वैयक्तिक ऑब्जेक्ट्सशी व्यवहार करत असतो सतत संवाद. तुम्ही एकाच प्रकारच्या अनेक ऑब्जेक्ट्ससह असोसिएशन स्टोअर करण्यासाठी ॲरे वापरू शकता, परंतु असोसिएशन अद्याप युनिटी एडिटरमध्ये सेट केल्या पाहिजेत आणि रनटाइममध्ये नाही. रनटाइममध्ये ऑब्जेक्ट्स शोधणे अनेकदा सोयीचे असते आणि युनिटी हे करण्यासाठी दोन मुख्य मार्ग प्रदान करते, खाली वर्णन केले आहे.

बाल वस्तू शोधणे

काहीवेळा गेम सीनमध्ये शत्रू, वेपॉइंट्स आणि अडथळे यासारख्या एकाच प्रकारच्या अनेक वस्तूंचा वापर होऊ शकतो. एखाद्या विशिष्ट स्क्रिप्टमध्ये त्यांचा मागोवा घेणे आवश्यक असू शकते जे त्यांना व्यवस्थापित करते किंवा त्यावर प्रतिक्रिया देते (उदाहरणार्थ, सर्व वेपॉइंट्स पाथफाइंडिंग स्क्रिप्टद्वारे आवश्यक असू शकतात). या वस्तूंना जोडण्यासाठी व्हेरिएबल्स वापरणे शक्य आहे, परंतु प्रत्येक नवीन वेपॉईंट स्क्रिप्टमधील व्हेरिएबलमध्ये ड्रॅग करणे आवश्यक असल्यास ते डिझाइन प्रक्रिया कंटाळवाणे करेल. त्याचप्रमाणे, हटवताना मार्गबिंदूतुम्हाला गहाळ ऑब्जेक्टचा संदर्भ हटवावा लागेल. अशा प्रकरणांमध्ये, एकल पालक ऑब्जेक्टची मुले बनवून वस्तूंचा संच व्यवस्थापित करणे बरेचदा सोयीचे असते. पालकांच्या ट्रान्सफॉर्म घटकाचा वापर करून चाइल्ड ऑब्जेक्ट्स मिळवता येतात (सर्व गेम ऑब्जेक्ट्समध्ये ट्रान्सफॉर्मचा अंतर्भाव असतो):

युनिटी इंजिन वापरणे; पब्लिक क्लास वेपॉईंट मॅनेजर: MonoBehaviour ( सार्वजनिक ट्रान्सफॉर्म वेपॉइंट्स; व्हॉइड स्टार्ट() ( वेपॉइंट्स = नवीन ट्रान्सफॉर्म; int i = 0; foreach (Transform t in transform) ( waypoints = t; ) )

फंक्शन वापरून तुम्ही नावाने दिलेल्या चाइल्ड ऑब्जेक्ट देखील शोधू शकता