Unity3D में गेम सेव करना

यदि आप वेब के लिए आकस्मिक नहीं लिख रहे हैं और एक निर्दयी, कठोर बैगेल नहीं है, तो आप डेटा को डिस्क पर सहेजे बिना नहीं कर सकते।
यह एकता में कैसे किया जाता है? यहां पर्याप्त विकल्प हैं - लाइब्रेरी में एक प्लेयरप्रैफ़ क्लास है, आप एक्सएमएल या बायनेरिज़ में ऑब्जेक्ट्स को सीरियल कर सकते हैं, * SQL * में सेव कर सकते हैं, आप अंत में अपना पार्सर विकसित कर सकते हैं और फॉर्मेट को बचा सकते हैं।
आइए पहले दो विकल्पों पर करीब से नज़र डालें और उसी समय स्क्रीनशॉट के साथ लोड-सेव मेनू बनाने की कोशिश करें।

हम मानते हैं कि पाठक जो इस इंजन को आगे बढ़ाने के लिए बुनियादी कौशल को पढ़ता है। लेकिन एक ही समय में, आप PlayerPrefs, उसके पुस्तकालय में GUI, और सिद्धांत रूप में, क्रमांकन के बारे में नहीं जानते हैं, पर संदेह नहीं कर सकते। हम इस सब से निपटेंगे।
और इसलिए कि यह नोट बहुत रोमांचक और उपयोगी नहीं है, यह विंडोज़ के तहत मोबाइल / टैबलेट / ऑनलाइन उम्र - असेंबली में सबसे अप्रासंगिक विकल्प पर केंद्रित है (हालांकि, निश्चित रूप से, अधिक सामान्य बिंदु पर्याप्त हैं)।

• वैसे, हबेरे पर कुछ हफ़्ते पहले एक लेख आया था जिसमें लेखक ने उल्लेख किया था कि सेंट पीटर्सबर्ग मटमाख के सूचना विज्ञान विभाग में कंप्यूटर ग्राफिक्स के पाठ्यक्रम में यूनिटी 3 डी पास है। एक दिलचस्प तथ्य, इंजन की लोकप्रियता के बहुत सारे सबूत।
  हालाँकि यह आम तौर पर कितना अच्छा विचार है, मेरी राय में, चर्चा का विषय है। हो सकता है कि इस पर चर्चा करना सीरियलाइज़ेशन के मुद्दों से भी अधिक दिलचस्प होगा =)

एक और छोटा अस्वीकरण - मैं कवर किए गए किसी भी विषय में एक समर्थक नहीं हूं, इसलिए यदि कुछ चीजें अधिक सही ढंग से, आसान, अधिक सुविधाजनक, सुधार और परिवर्धन बहुत स्वागत योग्य हैं।

1. PlayerPrefs

सुविधाजनक निर्मित वर्ग। इंट, फ्लोट और स्ट्रिंग के साथ काम करता है। यह बहुत ही पारदर्शी है, लेकिन मैं अभी भी " मैं खिलाड़ीप्रेफ़् स को समझ सकता हूँ " जैसे मंचों पर नहीं मिला था, या "मुझे किसी भी तरह से PlayerPrefs से निपटने की जरूरत है", तो चलिए इसे एक सरल उदाहरण से देखते हैं।

1.1 एक दृश्य के भीतर आदिम उपयोग: हॉटकी पर क्विकसेव और क्विकॉडैड।

एक त्वरित उपयोग मामला। मान लीजिए कि हमारे पास एक दृश्य और एक चरित्र है। SaveLoad.cs स्क्रिप्ट वर्ण से जुड़ी हुई है। हम सबसे सरल रखेंगे - इसकी स्थिति।

using UnityEngine; using System.Collections; public class SaveLoad : MonoBehaviour { public Transform CurrentPlayerPosition; void Update () { if(Input.GetKeyDown(KeyCode.R)) savePosition(); if(Input.GetKeyDown(KeyCode.L)) if (PlayerPrefs.HasKey("PosX")) // ,       loadPosition(); if(Input.GetKeyDown(KeyCode.D)) PlayerPrefs.DeleteAll(); //       } public void savePosition(){ Transform CurrentPlayerPosition = this.gameObject.transform; PlayerPrefs.SetFloat("PosX", CurrentPlayerPosition.position.x); // ..   PlayerPrefs.SetFloat("PosY", CurrentPlayerPosition.position.y); //   ,   PlayerPrefs.SetFloat("PosZ", CurrentPlayerPosition.position.z); //  float   PlayerPrefs.SetFloat("AngX", CurrentPlayerPosition.eulerAngles.x); PlayerPrefs.SetFloat("AngY", CurrentPlayerPosition.eulerAngles.y); PlayerPrefs.SetString("level", Application.loadedLevelName); //   /  PlayerPrefs.SetInt("level_id", Application.loadedLevel); //   } public void loadPosition(){ Transform CurrentPlayerPosition = this.gameObject.transform; Vector3 PlayerPosition = new Vector3(PlayerPrefs.GetFloat("PosX"), PlayerPrefs.GetFloat("PosY"), PlayerPrefs.GetFloat("PosZ")); Vector3 PlayerDirection = new Vector3(PlayerPrefs.GetFloat("AngX"), //    PlayerPrefs.GetFloat("AngY"), 0); //     CurrentPlayerPosition.position = PlayerPosition; //    CurrentPlayerPosition.eulerAngles = PlayerDirection; } } 

बेशक, यहां प्लेयरप्रैफ़्स का उपयोग बहुत दूर की बात है - वास्तव में, साधारण चर के मुकाबले, यह हमें बाहर निकलने के बाद गेम को सेव लोकेशन से डाउनलोड करने की सुविधा देता है।

लेकिन कक्षा का पूरा मुख्य इंटरफ़ेस दिखाई देता है: कुंजी द्वारा तीन गेट / सेट प्रकारों में से प्रत्येक के लिए, कुंजी प्रविष्टियों की जांच, समाशोधन। यह भी कोई मतलब नहीं है ScriptReference पार्स करने के लिए, कार्यों के नामों से सब कुछ स्पष्ट है: PlayerPrefs

हालाँकि, एक अभी भी अधिक विस्तार से रहने लायक है, PlayerPrefs.Save। विवरण में कहा गया है कि सामान्य तौर पर, डिफ़ॉल्ट इकाई प्लेयरप्रिफ़ को डिस्क को केवल तब लिखती है जब एप्लिकेशन बंद होता है - सामान्य तौर पर, यह तर्कसंगत है, यह देखते हुए कि वर्ग आंतरिक डेटा विनिमय पर केंद्रित नहीं है, लेकिन सत्रों के बीच उन्हें बचाने पर। तदनुसार, सहेजें () का उपयोग केवल क्रैश की स्थिति में आवधिक बचत के लिए किया जाना चाहिए।

शायद कुछ मामलों में यह काम करता है। Win PlayerPrefs के तहत रजिस्ट्री को लिखा जाता है, और, जैसा कि आप आसानी से देख सकते हैं, तुरंत पढ़ा और लिखा जाता है।
रजिस्ट्री में हमारी कक्षा कुछ इस तरह दिखती है:



अंत में सभी कुंजियों को जोड़ा गया है उनका DJBX33X हैश (XOR के साथ बर्नशेटिन हैश)।

UnityGraphicsQuality हमेशा स्वचालित रूप से सहेजा जाता है, और वास्तव में जब अनुप्रयोग बंद होता है। यह Edit -> प्रोजेक्ट सेटिंग्स गुणवत्ता से गुणवत्ता स्तर है, यह QualitySettings.SetQualityLevel भी है।

जब आवेदन चल रहा है, तो आप रजिस्ट्री में सहेजे गए मूल्य को संशोधित कर सकते हैं, फिर कार्यक्रम से अनुरोध कर सकते हैं - और हम देखेंगे कि संशोधित संस्करण वापस आ गया है। यानी आपको यह नहीं सोचना चाहिए कि प्लेयरप्रैफ़्स प्रोग्राम चल रहा है, यह वैश्विक चर के एनालॉग की तरह कुछ है, और डिस्क काम नहीं करता है।

2. एक्सएमएल में सीरियलाइजेशन

हम कहते हैं कि क्रमबद्धता, हमारा मतलब है बाइनरी कोड। यह होता है , लेकिन वास्तव में आप किसी भी प्रारूप में क्रमबद्ध कर सकते हैं। संक्षेप में, यह डेटा संरचना या किसी वस्तु की स्थिति का एक संग्रहीत / प्रेषित प्रारूप में अनुवाद है। और क्रमशः डीरियलाइज़ेशन, संग्रहीत / प्राप्त डेटा से किसी ऑब्जेक्ट की बहाली है।

सामान्य तौर पर, मोनो द्विआधारी क्रमांकन और एक्सएमएल (System.Xml.Serialization) दोनों कर सकते हैं, लेकिन एक बिंदु है: अधिकांश यूनिटी वर्ग सीधे क्रमबद्ध नहीं हैं। आप केवल GameObject, या एक वर्ग है कि MonoBehavoir विरासत में मिला नहीं कर सकते हैं: आपको एक अतिरिक्त आंतरिक क्रमिक वर्ग बनाना होगा जिसमें आवश्यक डेटा और इसका उपयोग करके काम करना होगा। लेकिन XmlSerializer कम से कम वेक्टर 3 को स्वचालित रूप से खाता है, और बाइनरीसेरलाइज़र, afaik, नहीं जानता कि कैसे।

२.१ उदाहरण का सार

कल्पना करें कि आप अपना पोर्टल लिख रहे हैं, जहां नायक एक ही प्रकार के स्थानों की एक श्रृंखला से गुजरता है - लेकिन वह बाद में उनमें से किसी पर लौट सकता है। इसके अलावा, वह सभी पर प्रभाव डाल सकता है: कुछ संसाधनों का उपयोग करें, कुछ को तोड़ दें, कुछ को बिखेर दें। मैं इन परिवर्तनों को सहेजना चाहता हूं, लेकिन स्थान पर वापस आना असंभव और अप्रत्याशित है, और रैम में सभी कमरों के मापदंडों के साथ घसीटने का बहुत मतलब नहीं है। हम स्थान को अनुक्रमित करेंगे, इसे छोड़कर - उदाहरण के लिए, दरवाजे पर एक ट्रिगर द्वारा। और स्थान को लोड करते समय, या तो एक डिफ़ॉल्ट स्थिति उत्पन्न करें, या, यदि डेटा सहेजा गया है, तो उन्हें पुनर्स्थापित करें।

2.2 डेटा के लिए अनुक्रमिक कक्षाएं

XmlSerializer उन कक्षाओं के साथ काम कर सकता है, जिनके डेटा में अन्य क्रमिक कक्षाएं, सरल प्रकार और संग्रह के अधिकांश तत्व [.Generic] शामिल हैं। श्रेणी में सभी सीरियल योग्य क्षेत्रों के लिए एक खाली निर्माता और सार्वजनिक पहुंच होनी चाहिए।
यूनिटी लाइब्रेरी से कुछ प्रकार (जैसे वेक्टर 3, जिसमें केवल तीन इंट फील्ड हैं) सफलतापूर्वक इस फेस कंट्रोल को पास करते हैं, लेकिन अधिकांश, विशेष रूप से अधिक जटिल वाले, विफल हो जाते हैं।

मान लीजिए कि प्रत्येक कमरे में हमें गेमऑब्जेक्ट्स के कुछ मनमाने सेट को बचाने की आवश्यकता है। हम सीधे यह नहीं कर सकते। इसलिए हमें डुप्लिकेट प्रकारों की आवश्यकता है।

मानक आस्तियों में एक नई स्क्रिप्ट बनाएँ:

 using UnityEngine; using System.Collections.Generic; using System.Xml.Serialization; using System; [XmlRoot("RoomState")] [XmlInclude(typeof(PositData))] public class RoomState { // ,      [XmlArray("Furniture")] [XmlArrayItem("FurnitureObject")] public List<PositData> furniture = new List<PositData>(); //     public RoomState() { } //   public void AddItem(PositData item) { //   -    furniture.Add(item); //      } public void Update(){ // ,     -  foreach (PositData felt in furniture) //   felt.Update(); } } 

वर्ग कोष्ठक में XML क्रमांकन को नियंत्रित करने के लिए विशेषताएँ हैं। यहां वे वास्तव में उत्पन्न * .xml में केवल टैग नामों को प्रभावित करते हैं, और कड़ाई से बोलते हुए, उनके लिए कोई आवश्यकता नहीं है। लेकिन उन्हें स्पष्टता के लिए रहने दें :) अगर किसी कारण से यह अचानक आपके लिए मायने रखता है कि एक्सएमएल-कोड कैसे दिखेगा, तो विशेषताओं की संभावनाएं निश्चित रूप से व्यापक हैं ।

इसके अलावा वहाँ हम सूची से आइटम के लिए आधार वर्ग जोड़ते हैं और जितना संभव हो उतना विरासत में मिला है। हालांकि ... उदाहरण के लिए, एक पर्याप्त है:

 [XmlType("PositionData")] [XmlInclude(typeof(Lamp))] public class PositData { protected GameObject _inst; //       public GameObject inst { set { _inst = value; } } [XmlElement("Type")] public string Name { get; set; } //      Resourses [XmlElement("Position")] public Vector3 position {get; set; } public PositData() { } public PositData(string name, Vector3 position) { this.Name = name; this.position = position; } public virtual void Estate(){ } //  ""    public virtual void Update(){ //    position = _inst.transform.position; //      } } [XmlType("Lamp")] public class Lamp : PositData // ,  ,    / { [XmlAttribute("Light")] public bool lightOn { get; set; } public Lamp() { } public Lamp(string name, Vector3 position, bool lightOn): base(name, position) { this.lightOn = lightOn; } public override void Estate(){ if (!lightOn) ((Light)(_inst.GetComponentInChildren(typeof(Light)))).enabled = false; } //   ,     Light  public override void Update(){ base.Update(); lightOn = ((Light)_inst.GetComponentInChildren(typeof(Light))).enabled; } // lightOn =    Light   } 

तो क्रमबद्ध कक्षाएं तैयार हैं। अब हम बनाए गए RoomState प्रकार के क्रमांकन को सरल बनाने के लिए एक और वर्ग बनाएंगे।

2.3 प्रत्यक्ष रूप से क्रमांकन

स्टैंडर्ड एसेट्स में भी हम कुछ स्टैटिक विधियों के साथ एक क्लास बनाएंगे, जिसका उपयोग हम भविष्य में करेंगे:

 using System.Xml.Serialization; using System; using System.IO; public class Serializator { static public void SaveXml(RoomState state, string datapath){ Type[] extraTypes= { typeof(PositData), typeof(Lamp)}; XmlSerializer serializer = new XmlSerializer(typeof(RoomState), extraTypes); FileStream fs = new FileStream(datapath, FileMode.Create); serializer.Serialize(fs, state); fs.Close(); } static public RoomState DeXml(string datapath){ Type[] extraTypes= { typeof(PositData), typeof(Lamp)}; XmlSerializer serializer = new XmlSerializer(typeof(RoomState), extraTypes); FileStream fs = new FileStream(datapath, FileMode.Open); RoomState state = (RoomState)serializer.Deserialize(fs); fs.Close(); return state; } } 

यहाँ हम कंस्ट्रक्टर कंस्ट्रक्टर (टाइप, टाइप [] के माध्यम से XmlSerializer बनाते हैं )
किसी विशिष्ट स्थान द्वारा प्रेषित सहेजे गए पते पर FileStream खोलें।

के उपयोग

तो, सभी सहायक उपकरण तैयार हैं, आप कमरे में ही आगे बढ़ सकते हैं। हम कमरे की वस्तु पर लटकते हैं:

 public class RoomGen : MonoBehaviour { private RoomState state; //   private string datapath; //        void Start () { datapath = Application.dataPath + "/Saves/SavedData" + Application.loadedLevel + ".xml"; if (File.Exists(datapath)) //      state = Serializator.DeXml(datapath); //  state  else setDefault(); //    Generate(); //      state } void setDefault(){ state = new RoomState(); // chair, table, lamp -    Resourses state.AddItem(new PositData("chair", new Vector3(15f, 1f, -4f))); state.AddItem(new PositData("chair", new Vector3(10f, 1f, 0f))); state.AddItem(new PositData("table", new Vector3(5f, 1f, 4f))); state.AddItem(new Lamp("lamp", new Vector3(5f, 4f, 4f), true)); } void Generate(){ foreach (PositData felt in state.furniture){ //      felt.inst = Instantiate(Resources.Load(felt.Name), felt.position, Quaternion.identity) as GameObject; //   felt.Estate(); //     } } void Dump() { state.Update(); //   state Serializator.SaveXml(state, datapath); //    } } 

अंत में, RoomGen.Dump () को कॉल करें। मान लीजिए, उदाहरण के लिए, उन दरवाजों पर ट्रिगर द्वारा जो एक कमरे के सापेक्ष बाल वस्तुएं हैं (एक रूमगैन घटक के साथ एक वस्तु):

 using UnityEngine; using System.Collections; public string nextRoom; public class Door : MonoBehaviour { void OnTriggerEnter(Collider hit) { if (hit.gameObject.tag == "Player") { SendMessageUpwards("Dump"); Application.LoadLevel(nextRoom); } } } 

वह सब है। यहां, वस्तुओं के साथ वास्तविक बातचीत और उनके राज्य को बदलने की प्रक्रिया को छोड़ दिया जाता है, लेकिन इसे जोड़ना मुश्किल नहीं है। प्रारंभिक परीक्षण के लिए, आप बस हॉटकी द्वारा राज्य-सेटिंग कार्यों की एक जोड़ी को स्क्रिप्ट में जोड़ सकते हैं, या अपने हाथों को रोक सकते हैं और स्थानांतरित कर सकते हैं।

पहली शुरुआत में, डिफ़ॉल्ट संस्करण उत्पन्न होता है, बाहर निकलने पर, परिवर्तनों को फ़ाइल में डंप कर दिया जाता है, वापसी पर, फ़ाइल से अंतिम स्थिति को बहाल किया जाता है, जिसमें कि आवेदन बंद हो गया था। आकर्षण की तरह काम करता है।

XML की एक बड़ी खामी यह है कि एक खिलाड़ी आसानी से डेटा को संशोधित कर सकता है। और अगर इस मामले में कुछ लोग बिखरे हुए कुर्सियों की व्यवस्था में रुचि रखते हैं, तो एक्सएमएल में खिलाड़ी के लिए क्रमांकन डेटा को अधिक महत्वपूर्ण बचाते हुए, बचना बेहतर है। हां, और रजिस्ट्री में मूल्यों को बदलने के लिए मुश्किल नहीं है। ऐसे मामलों में, द्विआधारी क्रमांकन या अपने स्वयं के प्रारूप का उपयोग करना पहले से ही बेहतर है।

3. मेनू के माध्यम से सहेजें / लोड करें

यह शायद उपयोगकर्ता चयन / निर्माण और आंतरिक स्वचालित बचत के साथ विकल्प को लागू करने के लिए अधिक प्रासंगिक होगा। यदि आपके गेम को गंभीर सहेजें / लोड मेनू की आवश्यकता है, तो यह संभावना नहीं है कि आप अब इस लेख को अपवित्र के लिए पढ़ रहे हैं।

लेकिन मैं नए साल की छुट्टियों के लिए इंतजार नहीं कर सकता जब मैं अपनी बहन को देख सकता हूं और एक दो रातों में क्लासिक अमेरिकी मैकगी के ऐलिस को खत्म कर सकता हूं, इसलिए हम लगभग इस तरह से सेव / लोड करेंगे। स्क्रीनशॉट के साथ। उसी समय जीयूआई, बनावट और अन्य रोमांचक चीजों में तल्लीन करने का एक कारण होगा।

3.1 मुख्य मेनू

मेनू के माध्यम से लोडिंग और बचत करने के लिए, अजीब तरह से, हमें एक मेनू की आवश्यकता है। बेशक, आप इसे मंच पर वस्तुओं के माध्यम से खुद कर सकते हैं, आप एनजीयूआई प्रकार के लिए तैयार समाधान बना सकते हैं, लेकिन अब हम नियमित पुस्तकालय से जीयूआई का उपयोग करेंगे।

• स्क्रिप्टिंग संदर्भ
  शुरुआत के लिए काम में आते हैं:
  OnGUI() - GUI को प्रस्तुत करने और इससे संबंधित घटनाओं को संभालने के लिए मोनोबीहैरौर फ़ंक्शन। अपडेट () जैसे कुछ, लेकिन विशेष रूप से जीयूआई के लिए, इसे हर फ्रेम की तुलना में अधिक बार कहा जा सकता है।
  
  GUI.Button
  

   static bool Button(Rect position, String text); static bool Button(Rect position, Textureimage ); 

  
  बटन समारोह। निर्दिष्ट आयत के भीतर इसे खींचता है, एक क्लिक पर प्रतिक्रिया देता है, सच लौटाता है। अधिक निर्माता हैं, लेकिन ये हमारे लिए पर्याप्त हैं।
  
  GUI.BeginGroup , GUI.EndGroup
  

   static void BeginGroup (Rect position); static void EndGroup (); 

  
  किसी gooey के तत्वों का समूहन मुख्य रूप से उन सीमाओं को पुनर्परिभाषित करने के लिए उपयोगी होता है, जिनके संबंध में नेस्टेड तत्वों की स्थिति की गणना की जाती है (डिफ़ॉल्ट स्क्रीन की सीमा है, इस मामले में, स्थिति आयत)।
  
• दिल
  आइए एक अलग प्रारंभिक दृश्य बनाते हैं, और उस पर एक खाली वस्तु है, जिसके लिए हम अपने मेनू के लिए एक स्क्रिप्ट संलग्न करेंगे। इस प्रकार मेनू दृश्यों के माध्यम से यात्रा करेगा (जब एक और दृश्य लोड कर रहा है, तो इसे फिर से बनाया नहीं गया है, लेकिन बस इसे स्थानांतरित कर दिया गया है), आवश्यक घटनाओं को संभालें (मेनू बटन की तरह), जब खींचा जाता है, तो गेम स्क्रीन के शीर्ष पर ड्रा करें।
  
• टिप्पणियों के साथ कोड के अनुसार, सब कुछ स्पष्ट होना चाहिए:

 public class MenuScript : MonoBehaviour { public Texture2D backgroundTexture; //     public const int mainMenuWidth = 200; //      private int menutype = 0; //    -   private bool menuMode = true; //    private bool gameMode = false; //     - // false    Load / New Game private void Awake(){ DontDestroyOnLoad(this); //          } void Update () { if (Input.GetKeyDown(KeyCode.Escape)){ // warning!      : Input.GetKey() if(gameMode) if (menutype == 0 || !menuMode){ //          switchGameActivity(); // /   // (     ) menuMode = !menuMode; } menutype = 0; //         } //       } private void OnGUI(){ if (menuMode){ if(backgroundTexture != null) // ,  GUI.DrawTexture(new Rect(0, 0, Screen.width, Screen.height), backgroundTexture); switch (menutype){ case 0: drawMainMenu(); break; case 1: case 2: drawSaveLoadMenu(); break; } } } private void drawMainMenu(){ GUI.BeginGroup (new Rect (Screen.width / 2 - mainMenuWidth/2, Screen.height / 2 - 180, mainMenuWidth, 240)); if (gameMode) if(GUI.Button(new Rect(0,0, mainMenuWidth,30) , "Resume")){ menuMode = false; switchMouseLook(); } if(GUI.Button(new Rect(0, 40, mainMenuWidth, 30) , "New Game")){ menuMode = false; gameMode = true; Application.LoadLevel("first_scene"); } if (gameMode) if(GUI.Button(new Rect(0, 2*40, mainMenuWidth, 30) , "Save")) menutype = 1; if(GUI.Button(new Rect(0, ((gameMode)? 3 : 2)*40, mainMenuWidth, 30) , "Load")){ menutype = 2; //   "2 + gameMode"? C#, nuff said. if(GUI.Button(new Rect(0, ((gameMode)? 4 : 3)*40, mainMenuWidth, 30) , "Options")){} if(GUI.Button(new Rect(0, ((gameMode)? 5 : 4)*40, mainMenuWidth, 30) , "Quit Game")){ Application.Quit(); } GUI.EndGroup(); } void switchGameActivity(){ //    c,       MouseLook, Camera mk = Camera.main; //     .    MouseLook ml = mk.GetComponent<MouseLook>(); //      if (ml != null) ml.enabled = !ml.enabled; //    } } 

खेल की शुरुआत से पहले और बाद में मुख्य मेनू

3.2 हम लोडिंग / सेविंग का मेनू बनाते हैं

DrawSaveLoadMenu () फ़ंक्शन को पहले से ही कहा जाता है जब menutype> 0, लेकिन अभी तक नहीं लिखा गया है। इस चूक को ठीक करो। अभी के लिए, हम बस सीखेंगे कि हमारे मेनू कैसे बनाएं और वास्तविक लोड / फ़ंक्शन को कैसे कॉल करें।

• स्क्रिप्टिंग संदर्भ
  GUI.SelectionGrid - बटन का एक ग्रिड खींचता है, लेकिन वास्तव में यह एक एकल GUI.SelectionGrid । एक विकल्प हमेशा चुना जाता है, चयनित की संख्या लौटाता है।
  

   static int SelectionGrid (Rect position , int defaultSelected, Texture[] images, int elsInRow); static int SelectionGrid (Rect position , int defaultSelected, string[] texts, int elsInRow); 

  
  मात्रा - संचरित सरणी के आकार के आधार पर। आम तौर पर इस तरह से कुछ इस्तेमाल करने का इरादा:
  

   public int selGridInt = 0; //       public string[] selStrings = new string[] {"Grid 1", "Grid 2", "Grid 3", "Grid 4"}; void OnGUI() { //        selGridInt = GUI.SelectionGrid(new Rect(25, 25, 100, 30), selGridInt, selStrings, 2); //  selGridInt    , } //    ,         

  
  
• दिल
  ऐसा लगता है कि यह वही नहीं है जो हमें चाहिए - हमें एक बार चुनने और तुरंत जवाब देने की आवश्यकता है। लेकिन SelectionGrid चुपचाप एक गंदे हैक खाती है - वास्तविक सरणी के बाहर एक सूचकांक। यानी हम हमेशा पास होंगे, कहते हैं -1 और फिर हम वास्तविक क्लिक ईवेंट को ट्रैक कर सकते हैं।
  

 public const int slotsAmount = 10; //   / //   .    , private Texture2D[] saveTexture = new Texture2D[slotsAmount]; //  ,     //,         ,  null private void drawSaveLoadMenu(){ if(GUI.Button(new Rect(Screen.width / 2 - 100, Screen.height * 2/3 + 50, 200, 30) , "Back")) menutype = 0; int slot = GUI.SelectionGrid( new Rect( //      5x2 Screen.width / 2 - Screen.height * 5/9, //   Screen.height/3, //   4:3 Screen.height * 10/9, Screen.height/3 ), -1, //     saveTexture, //  null,     5); //     if (slot >= 0) //      if (menutype == 1) savegame(slot); //      -  else if (menutype == 2 && saveTexture[slot] != null) loadgame (slot); } //       - .       , //          

SelectionGrid पर लोड मेनू - संबंधित सहेजें से अलग नहीं दिखता है

इस समाधान के बारे में मुझे जो मुख्य बात पसंद नहीं है, वह यह है कि बूट मेनू में, नॉन-सेविंग स्लॉट अपेक्षाकृत सक्रिय रहते हैं - वे केवल बनावट की कमी से भिन्न होते हैं, वे होवर का जवाब देते हैं। इसलिए, एक बोनस हैंडल के साथ ग्रिड है, निष्क्रिय बटनों के बजाय हम सक्रिय बटन के लिए बॉक्स को आकर्षित करते हैं।
उसी समय, हम रबर जोड़ते हैं: प्रति पंक्ति स्लॉट्स की संख्या सेट की जाती है, स्लॉट्स का आकार स्क्रीन पर समायोजित होता है। सच है, यहां वे पहले से ही चौकोर हैं, लेकिन एक मनमाना पहलू अनुपात एम्बेड करना मुश्किल नहीं होगा :) ठीक है, उसी समय, GUILayout से न्यूनतम / अधिकतम चौड़ाई / ऊंचाई और अन्य फ़ाइल प्रसंस्करण।

 public const int slotsAmount = 10; public const int hN = 5; public const int margin = 20; static private int vN = (int)Mathf.Ceil((float)slotsAmount/hN); private Texture2D[] saveTexture = new Texture2D[slotsAmount]; private int slotSize = ((Screen.width*vN)/(Screen.height*hN) >= 1) ? Screen.height/(vN + 2) : Screen.width/(hN + 2); private void drawSaveLoadMenu(){ GUI.BeginGroup (new Rect ( Screen.width / 2 - (slotSize*hN - margin) / 2, Screen.height / 2 - (slotSize*vN - margin) / 2, slotSize*hN - margin, slotSize*vN + 40)); for (int j = 0; j < vN; j++) for (int i = 0, curr = j*hN; (curr = j*hN + i) < slotsAmount; i++){ if (menutype == 2 && saveTexture[curr] == null) GUI.Box(new Rect(slotSize*i, slotSize*j, slotSize - margin, slotSize - margin), ""); else if(GUI.Button(new Rect(slotSize*i, slotSize*j, slotSize - margin, slotSize - margin), saveTexture[curr])){ if (menutype == 1) savestuff(curr); else if (menutype == 2) loadstuff (curr); } } if(GUI.Button(new Rect(slotSize*hN/2 - 100, slotSize*vN , 200, 30) , "Back")) menutype = 0; GUI.EndGroup(); } 

बटन और बॉक्स पर लोड मेनू - अब खाली स्लॉट निष्क्रिय हैं

3.3 बनावट, स्क्रीनशॉट

इसलिए, जब से हम अपना मेनू ऑब्जेक्ट बनाते हैं, तब तक हम टेक्सचर की एक सरणी रखेंगे। इसमें थोड़ी मेमोरी लगती है और हमें इसमें तुरंत एक्सेस की गारंटी दी जाती है। वास्तव में, यहां कोई विशेष विकल्प नहीं है - डिस्क के साथ काम को onGUI () में न धकेलें।

जैसा कि हम पहले ही देख चुके हैं कि अपना मेनू बनाते समय, हम एक सरणी भी बनाते हैं:

 private Texture2D[] saveTexture = new Texture2D[slotsAmount]; 

हम न केवल बचत की जानकारी को बचाएंगे, बल्कि उनके बारे में भी जानकारी देंगे , या जो विशेष स्लॉट में बचत होती है। स्टोर कैसे करें - प्रत्येक को प्रत्येक स्लॉट के लिए पैरामीटर 0/1 द्वारा चुना जा सकता है, 0/1 से एक लाइन हो सकती है, लेकिन हम इसे बदसूरत कर देंगे :) और इंट में बिट वेक्टर लेते हैं। किस बिंदु पर और कैसे संग्रहीत किया जाता है, हम बाद में देखेंगे, जबकि हम सिर्फ पढ़ रहे हैं।
प्रारंभ में जोड़ें ():

 int gS = PlayerPrefs.GetInt("gamesSaved"); for (int i = 0; i < slotsAmount && gS > 0; i++, gS/=2) if (gS%2 != 0){ saveTexture[i] = new Texture2D(Screen.width/4, Screen.height/4); //    ,      saveTexture[i].LoadImage(System.IO.File.ReadAllBytes(Application.dataPath + "/tb/Slot" + i + ".png")); } //  , ,    ,  . 

खैर, वास्तव में इस मामले में मुख्य बात यह है कि स्क्रीनशॉट को कैसे बचाया जाए? Application.CaptureScreenshot विकल्प Application.CaptureScreenshot , लेकिन अभी दो तरकीबें हैं। सबसे पहले, वे पूर्ण आकार में सहेजे जाते हैं, और अंत में हमें केवल थंबनेल की आवश्यकता होती है, यह तुरंत आकार बदलने के लिए अधिक तर्कसंगत है। दूसरी बात, हम एक ग्रन्थ की एक सारणी बना रहे हैं, क्या हमें इसे डिस्क से दोबारा पढ़ना होगा? बहुत अच्छा नहीं है।

स्क्रीनशॉट लेने और रिकॉर्ड करने का कार्य बाद में कहा जाएगा, लेकिन अब हम पहले से ही Coroutine में चयन करेंगे:

 IEnumerator readScreen(int i){ yield return new WaitForEndOfFrame(); //     ,       :) int adjustedWidth = Screen.height * 4/3; // ,       Texture2D tex1 = new Texture2D(adjustedWidth, Screen.height); //        tex1.ReadPixels(new Rect((Screen.width - adjustedWidth)/2, 0, adjustedWidth, Screen.height), 0, 0, true); tex1.Apply(); //     Texture2D tex = new Texture2D(Screen.height/3, Screen.height/4, TextureFormat.RGB24, true); tex.SetPixels(tex1.GetPixels(2)); //        Destroy(tex1); tex.Apply(); saveTexture[i] = tex; //     FileStream fs = System.IO.File.Open(Application.dataPath + "/tb/Slot" + i + ".png", FileMode.Create); BinaryWriter binary = new BinaryWriter(fs); binary.Write(tex.EncodeToPNG()); //    fs.Close(); } 

एक अप्रिय अनसुलझे क्षण - वर्तमान सत्र से बनावट और डिस्क से लोड की गई बनावट गुणवत्ता में बहुत भिन्न होती है।
पिछले सत्र से डिस्क के दाईं ओर दो, नीचे डिस्क पर दो:

3.4 वास्तव में लोडिंग को बचाने का कार्यान्वयन है

तो, यह भूसी को हल करने के लिए लगता है। हमने सीखा कि कैसे GUI के साथ न्यूनतम काम करना है, एक सरल मेन मेनू, सेव / लोड मेनू बनाया, स्क्रीनशॉट के साथ काम करने का तरीका सीखा।

दृश्य वस्तुओं के बीच बातचीत को कैसे लागू किया जाए, जिसके पैरामीटर हम सहेजेंगे और हमारे मेनू?

1. यदि हम पहले दृश्य से केवल उसी वस्तु की स्थिति और अविनाशी को आगे रिकॉर्ड करते हैं (उदाहरण के लिए, खिलाड़ी, उसके मापदंडों और उपकरण), तो आप तुरंत एक सीधा लिंक रख सकते हैं।

2. GameObject.Findऔर GameObject.FindWithTagयहां इसका उपयोग करना लगभग शर्म की बात नहीं है - लोडिंग / सेविंग एक बार की घटना है। आप सीधे खोज सकते हैं, और चूंकि दृश्यों में अलग-अलग जानकारी हो सकती है - फिर, एक विकल्प के रूप में, एक विशेष टैग के साथ प्रत्येक विशेष ऑब्जेक्ट को जोड़ें, जिससे स्क्रिप्ट वास्तविक दृश्य को खुद ही सहेज / लोड कर देगी, यहां आप पहले से ही आवश्यक वस्तुओं के लिए सीधे लिंक रख सकते हैं।

3. <अन्य विकल्पों के लिए आरक्षित जगह अधिक इष्टतम, सुझाव! >

इस बीच, इस तरह के एक सरल विकल्प पर विचार करें। हम केवल दृश्य और खिलाड़ी की स्थिति को बचाएंगे। प्रत्येक दृश्य में खिलाड़ी को फिर से बनाया गया है, लेकिन हमेशा एक प्रथम-व्यक्ति दृश्य होता है, और तदनुसार, एक कैमरा खिलाड़ी से जुड़ा होता है।
इसके माध्यम से हम पहुंच पाएंगे। नीचे दिए गए फ़ंक्शन में, यह सभी विशिष्टता // लेबल की गई दो लाइनों में है! और इसे स्थानीय रूप से प्रतिस्थापित करना मुश्किल नहीं है, बाकी हमने ऊपर लिखे कोड से बंधा है।

 void savegame(int i) { PlayerPrefs.SetInt("slot" + i + "_Lvl", Application.loadedLevel); //    // ! Interface i = Camera.main.GetComponent<Interface>(); if (i != null) i.save(i); //     PlayerPrefs    menuMode = false; //    switchGameActivity(); //   //    .     . //   ,      . //           PlayerPrefs.SetInt("gamesSaved", PlayerPrefs.GetInt("gamesSaved") | (1 << i)); StartCoroutine(readScreen(i)); //        } 

यदि आप पहले से स्क्रीनशॉट लेते हैं, तो सबसे पहले, यह उपयोगी नहीं हो सकता है, और दूसरी बात, आपको अभी भी इसे बनाना होगा। और इसलिए, कैमरा को मेनू मोड में ब्लॉक करने को ध्यान में रखते हुए, परिणाम उसी के बारे में है।

डाउनलोड करना और भी आसान है। हम फिर से पूरी तरह से सभी बारीकियों को सौंपते हैं, और हम इसे सीधे लागू नहीं करेंगे। बस वांछित स्तर को लोड करें, और फिर वे किसी तरह किसी भी तरह :)

 void loadgame(int i) { if (gameMode) //  Load  ,      switchGameActivity(); PlayerPrefs.SetInt("Load", i); //    ,    Application.LoadLevel(PlayerPrefs.GetInt("slot" + i + "_Lvl")); //    menuMode = false; gameMode = true; //  ,      } 

अब व्यवहार करते हैं कि हम कैमरों को लटकाएंगे:

 public class Interface : MonoBehaviour { private Transform CurrentPlayerPosition; public virtual void Start () { int load = PlayerPrefs.GetInt("Load"); // ,     if (load >= 0){ //  -   load(load); PlayerPrefs.SetInt("Load", -1); //  Load } } public virtual void save(int i) { //          CurrentPlayerPosition = this.gameObject.transform.parent.transform; PlayerPrefs.SetFloat("slot" + i + "_PosX", CurrentPlayerPosition.position.x); PlayerPrefs.SetFloat("slot" + i + "_PosY", CurrentPlayerPosition.position.y); PlayerPrefs.SetFloat("slot" + i + "_PosZ", CurrentPlayerPosition.position.z); } public virtual void load(int i) { CurrentPlayerPosition = this.gameObject.transform.parent.transform; //        Vector3 PlayerPosition = new Vector3(PlayerPrefs.GetFloat("slot" + i + "_PosX"), PlayerPrefs.GetFloat("slot" + i + "_PosY"), PlayerPrefs.GetFloat("slot" + i + "_PosZ")); CurrentPlayerPosition.position = PlayerPosition; //   ,  } //     } 

यह ध्यान दिया जाना चाहिए कि "किसी भी तरह अपने दम पर आगे" चालाक की एक निश्चित डिग्री थी: ऑब्जेक्ट का लोडगेम () मेनू और लोड () निश्चित रूप से जानकारी का आदान-प्रदान किया, केवल एक ज्ञात स्थान के माध्यम से - रजिस्ट्री। वहाँ एक स्पष्ट अस्थायी चर को बचाने के लिए - चाल भी सुंदर नहीं है। आप इसे लोड करने के लिए डायरेक्ट कॉल में बदल सकते हैं (), और वर्तमान सामान्य संरचना को बदले बिना - मेनू में वेरिएबल को रखें, और लोड किए गए ऑब्जेक्ट के प्रारंभ () में मेनू ऑब्जेक्ट के लिए एक खोज जोड़ें और आवश्यक जानकारी प्राप्त करें।

इसके अलावा।निर्मित मूल व्यवहार से, हम विभिन्न दृश्यों और वस्तुओं के लिए अलग-अलग विकल्प प्राप्त कर सकते हैं। उदाहरण के लिए, रोटेशन को बचाने का विकल्प:

 public class InterfaceWAng : Interface { public override void Start () { base.Start(); } public override void save(int i) { base.save(i); PlayerPrefs.SetFloat("slot" + i + "_AngX", CurrentPlayerPosition.eulerAngles.x); PlayerPrefs.SetFloat("slot" + i + "_AngY", CurrentPlayerPosition.eulerAngles.y); } public override void load(int i) { base.load(i); Vector3 PlayerDirection = new Vector3(PlayerPrefs.GetFloat("slot" + i + "_AngX"), PlayerPrefs.GetFloat("slot" + i + "_AngY"), 0); CurrentPlayerPosition.eulerAngles = PlayerDirection; } } 

बेशक, संरक्षण यहाँ काम आया होगा। चूंकि PlayerPrefs के साथ सभी वास्तविक कार्य अलग-अलग सेव () / लोड () फ़ंक्शन में हाइलाइट किए गए हैं, उनकी सामग्री को बदलना मुश्किल नहीं होगा। किस लिए? आप भाग 2 में उदाहरण के समान परावर्तक वर्ग को पकड़ सकते हैं, और बाइनरीसेरलाइज़र के माध्यम से इसे क्रमबद्ध कर सकते हैं।
एक और अच्छा विकल्प पेंच करना है, उदाहरण के लिए, SQLite। सच है, अफवाहों के अनुसार, जेएस के साथ शार्प के साथ काम करना अधिक सुविधाजनक है, लेकिन बाद के साथ सब कुछ अंततः शुरू हो जाएगा। कौन प्रयास करना चाहता है, आप यहां से शुरू कर सकते हैं ।

---

इस पाठ ने कभी भी बिना

काम नहीं किया होता: google
docs.unity3d.com
wiki.unity3d.com
forum.unity3d.com
answers.unity3d.com
stackoverflow.com

और हब्र। उनको धन्यवाद।
मुझे उम्मीद है कि यह सब किसी को फायदा पहुंचाएगा, और किसी को कोई नुकसान नहीं होगा :)