ईवो पार्ट 2 - क्रॉसिंग के बारे में

अभिवादन हरजितेली!

पोस्ट "खेल का एक एनालॉग" जीवन "- ईवो की निरंतरता में , मैं ईवो में प्रयुक्त" जीन भाषा "के आदेशों का अधिक विस्तृत विवरण देना चाहूंगा और इस खेल में व्यक्तियों को पार करने के तरीकों पर अपने विचार साझा करूंगा।

आनुवंशिक कोड

ईवो में व्यक्तियों का आनुवंशिक कोड लगभग असीमित लंबाई के बाइट्स का एक क्रम है। इसके अलावा, प्रत्येक बाइट को सेलुलर ऑटोमेटन के लिए एक कमांड के रूप में माना जाता है। मशीन में 2 टेप हैं: कमांड और मेमोरी। तदनुसार, दो बिंदु हैं cmd_ptr और mem_ptr । पशु की रैम के रूप में, चर डेटा का उपयोग 1 बाइट (8 बिट) के आयाम के साथ किया जाता है ।
वर्तमान में निम्नलिखित आदेश हैं:

• "आनुवंशिक" कोड के निष्पादन को नियंत्रित करने के लिए 9 टीमें:
  
  1. nop - कुछ मत करो
  2. Move_cmd_left - कमांड पॉइंटर को बाईं ओर ले जाएं
  3. Move_cmd_right - कमांड पॉइंटर को दाईं ओर ले जाएं
  4. jump_to - X पॉजिशन द्वारा कमांड पॉइंटर को दाईं ओर शिफ्ट करें (कमांड का पालन करते हुए बाइट को हस्ताक्षरित चार के रूप में माना जाता है, अर्थात, नकारात्मक मान पॉइंटर को बाईं ओर शिफ्ट करते हैं)
  5. jump_to_ifz - jump_to के समान, लेकिन बशर्ते कि डेटा का मूल्य == 0 हो
  6. jump_to_ifnz - jump_to के समान, लेकिन बशर्ते कि डेटा का मूल्य ! = 0 हो
  7. शुरुआत nop के समान है, कुछ अलग-थलग टुकड़े की शुरुआत के लिए सिर्फ एक लेबल (फ़ंक्शन की शुरुआत)
  8. पुनरारंभ - 0 पर cmd_ptr रीसेट करता है
  9. अंत - फ़ंक्शन का अंत, यह शुरू लेबल के लिए टेप को और नीचे दिखता है जिसके साथ निष्पादन जारी रखने के लिए (यदि कोई लेबल नहीं है, तो cmd_ptr = 0 )
• 8 आदेश जो पशुधन को अपने चारों ओर देखने की अनुमति देते हैं (परिणाम पशुधन रैम में संग्रहीत हैं, डेटा चर में):
  
  1. eye_up_distance - निकटतम वस्तु तक दूरी का मान प्राप्त करें
  2. eye_down_distance - निकटतम वस्तु के लिए दूरी का मान नीचे लाएं
  3. eye_left_distance - बाईं ओर के निकटतम ऑब्जेक्ट के लिए दूरी का मान प्राप्त करें
  4. eye_right_distance - निकटतम ऑब्जेक्ट के दाईं ओर दूरी का मान प्राप्त करें
  5. टच_अप - निकटतम वस्तु के प्रकार का मूल्य प्राप्त करें
  6. टच_डाउन - निकटतम ऑब्जेक्ट के प्रकार का मूल्य नीचे प्राप्त करें
  7. टच_लेफ्ट - बाईं ओर के निकटतम ऑब्जेक्ट के प्रकार का मान प्राप्त करें
  8. टच_ राइट - दाईं ओर निकटतम ऑब्जेक्ट के प्रकार का मान प्राप्त करें
• 10 लाइव मेमोरी प्रबंधन कमांड:
  
  1. Move_mem_left - mem_ptr पॉइंटर को बाईं ओर ले जाएं
  2. Move_mem_right - मेम_ptr पॉइंटर को बाईं ओर ले जाएं
  3. save_to_mem - वर्तमान सेल में पशुधन राम ( डेटा ) की सामग्री को सहेजें
  4. load_from_mem - पशुधन रैम ( डेटा ) में वर्तमान सेल से मूल्य लोड करें
  5. add_mem - डेटा में वर्तमान मेमोरी सेल का मान जोड़ें
  6. sub_mem - डेटा से वर्तमान मेमोरी सेल के मूल्य को घटाएं
  7. set_mem_ptr - RAM के मान के लिए mem_ptr सेट करें
  8. data_clear - स्वच्छ रैम
  9. data_inc - रैम में वृद्धि मूल्य
  10. data_dec - RAM में मान को घटाता है
• 12 कार्यों के लिए आदेश जो जानवर कर सकते हैं (विश्व वस्तु के लिए संकेत संचारित):
  
  1. action_move_left - पशुधन बाईं ओर चलता है
  2. Action_move_right - जीवित प्राणी बाईं ओर चलता है
  3. action_move_up - पशुधन बाईं ओर चलता है
  4. action_move_down - पशुधन बाईं ओर चलता है
  5. action_eat_left - जानवर बाईं ओर एक वस्तु खाने की कोशिश करते हैं
  6. action_eat_right - जानवर बाईं ओर एक वस्तु खाने की कोशिश करते हैं
  7. action_eat_up - जानवर बाईं ओर एक वस्तु खाने की कोशिश करते हैं
  8. action_eat_down - जानवर बाईं ओर एक वस्तु खाने की कोशिश करते हैं
  9. कार्रवाई_वाइट - पशुधन इंतजार कर रहा है, एक कदम लंघन
  10. action_suicide - जीवित प्राणी आत्म-विनाश
  11. Action_split - पशुधन को क्लोनिंग द्वारा साझा किया जाता है
  12. action_split_mutate - जानवर क्लोनिंग साझा करते हैं, लेकिन कुछ उत्परिवर्तन के साथ

कार्यक्रम का उदाहरण

सिद्धांत रूप में, आदेशों का ऐसा सेट छोरों और शाखाओं को करने के लिए पर्याप्त है। एक और सवाल यह है कि इस तरह की भाषा में एल्गोरिदम का वर्णन करना C ++ की तरह सुविधाजनक नहीं है, उदाहरण के लिए।
लेकिन एक उदाहरण के लिए मैं आपको एक कार्यक्रम दिखाऊंगा जो जीवित प्राणियों को एक वर्ग सर्पिल में ले जाता है:

start action_split load_from_mem //load from var1 move_mem_right //save var2 data_dec save_to_mem move_mem_right //save to var3 data_dec save_to_mem //right action_move_right data_dec jump_to_ifnz AnimalCommand(-3) //up load_from_mem data_dec save_to_mem action_move_up data_dec jump_to_ifnz AnimalCommand(-3) //left load_from_mem data_dec save_to_mem action_move_left data_dec jump_to_ifnz AnimalCommand(-3) //down load_from_mem data_dec save_to_mem action_move_down data_dec jump_to_ifnz AnimalCommand(-3) //dec var2 move_mem_left load_from_mem data_dec save_to_mem jump_to_ifnz AnimalCommand(-33) move_mem_left // restore var1 end; 

मेमोरी में, 3 मान लोड किए गए हैं: 10, 0, 0. मैं एल्गोरिथ्म नहीं समझाऊंगा। मेरी राय में, सब कुछ बहुत स्पष्ट है।
आप इस कोड को mainwindow.cpp : 117 में पा सकते हैं।

उत्परिवर्तन के बारे में

खेल में म्यूटेशन अब इस तरह से लागू किया जाता है। जीव के अनुरोध पर, क्लोन को एक उत्परिवर्तन के साथ गुणा करके बनाया जाता है। क्लोन 0 से 9 तक की राशि (महान यादृच्छिक के विवेक पर) में उत्परिवर्तन से गुजरता है। प्रत्येक उत्परिवर्तन के लिए, भव्य रैंडम 4 विकल्पों में से एक को चुनता है:

• कोड के 1 मनमाने बाइट को एक मनमाने मूल्य के साथ बदल दिया जाता है
• यादृच्छिक बाइट डीएनए में जोड़ा जाता है
• एक यादृच्छिक स्थिति में बाइट बिट
• एक मनमाना बाइट डीएनए में एक मनमाना स्थिति में डाला जाता है (ताजा प्रतिबद्ध )

चौराहे के बारे में

अब दो जीवों को कैसे पार करना है, इसके बारे में सोचने के लिए आगे बढ़ते हैं। उनका कोड अलग-अलग लंबाई का हो सकता है, उनकी अलग-अलग मेमोरी हो सकती है।

• पहली बात जो मन को भाती है, वह है 2 डीएनए को एक लंबी लंबाई में अंधा कर देना। लेकिन इस मामले में, एल्गोरिथ्म का दूसरा हिस्सा बिल्कुल काम नहीं कर सकता है, या यह शायद ही कभी काम कर सकता है। खैर, ठीक है - यह वास्तव में एक पुनरावर्ती जीन होगा।
• आप प्रत्येक डीएनए पर 3 मनमाना अंक ले सकते हैं और सिद्धांत के अनुसार एक नया इकट्ठा कर सकते हैं: पहले डीएनए से 0-1 का एक टुकड़ा, दूसरे से 1-2, पहले से 2-3, दूसरे से 3-4। इसके अलावा, टुकड़े शून्य लंबाई के हो सकते हैं।
• आप अलग-अलग जीवों के कार्यों को एक साथ रखकर नए सिरे से टैग और स्कैल्प तैयार कर सकते हैं। यह प्राणियों को किसी भी तरह से कोड को बनाने की कोशिश करने के लिए मजबूर करेगा।
• प्रत्येक जीव से एक बाइट चक्र में लेने का एक विकल्प है जब तक कि उनका डीएनए बाहर न निकल जाए। यह एक तरह का फ्रेंकस्टीन बन जाएगा, लेकिन इसके गुण बहुत दिलचस्प होंगे।

शायद यह सभी विकल्प हैं जो तुरंत मेरे दिमाग में आते हैं। मैंने स्मृति की विरासत के बारे में अभी तक नहीं सोचा था।
एक! यहाँ मैं क्या भूल गया था। आपको क्या लगता है बेहतर है?

1. एक्स राउंड के बाद, वाई-सबसे लें और उन्हें पार करें। उसी समय, पूरी आबादी को मार डालो, इन वाई व्यक्तियों और उनके वंश के साथ दुनिया को आबाद करें।
2. हर एक्स राउंड वाई (2 से 5 तक, कहते हैं) सबसे मजबूत होता है और उन्हें पार करता है, जिससे उनकी संतानें आबादी में बढ़ जाती हैं।
3. तीसरा विकल्प वह है जो आप टिप्पणी के साथ आते हैं और लिखते हैं।

विषय पर विचार निश्चित रूप से सघन नहीं हैं, लेकिन मैं फेरीवालों की समृद्ध कल्पना की आशा करता हूं।
आपका धन्यवाद प्रतिक्रिया की प्रतीक्षा है।