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

पृष्ठभूमि

कोर वार में, कंप्यूटर पर नियंत्रण के लिए जूझ रहे दो कार्यक्रम हैं। प्रत्येक कार्यक्रम का लक्ष्य विरोधी कार्यक्रम का पता लगाने और समाप्त करके जीतना है।

लड़ाई कंप्यूटर की मुख्य मेमोरी के भीतर होती है। इस मेमोरी को कोर कहा जाता है, और इसमें 8192 पते हैं। जब लड़ाई शुरू होती है, तो प्रत्येक प्रतियोगी (जिसे योद्धा कहा जाता है) के लिए कोड को स्मृति के यादृच्छिक क्रम में रखा जाता है। योद्धाओं के बीच कार्यक्रम निष्पादन वैकल्पिक, प्रत्येक के एक निर्देश का प्रदर्शन। प्रत्येक निर्देश कोर के एक हिस्से को संशोधित करने में सक्षम है, जिससे स्व-संशोधित कार्यक्रमों की संभावना बढ़ जाती है।

लक्ष्य विरोधी कार्यक्रम को समाप्त करना है। जब कोई अमान्य निर्देश निष्पादित करने का प्रयास करता है, तो एक कार्यक्रम समाप्त हो जाता है, जो कि कोई भी DATनिर्देश है।

निर्देश सेट

प्रत्येक कार्यक्रम में निम्न-स्तरीय निर्देशों की एक श्रृंखला होती है, जिनमें से प्रत्येक दो क्षेत्रों को लेता है, जिन्हें ए और बी फ़ील्ड कहा जाता है।

यह निर्देश सेट मूल कल्पना से भारी है। मुख्य जोड़ 1) कमांड जोड़ने / घटाने पर स्पष्टीकरण है, और 2) #एड्रेसिंग मोड का एक परिवर्तन इसे कहीं भी उपयोग करने की अनुमति देता है। कोर वार्स के अधिकांश पूर्ण संस्करणों में 20 से अधिक ऑपकोड, 8 एड्रेसिंग मोड और "इंस्ट्रूमेंट मॉडिफायर" का एक सेट है।

opcodes

प्रत्येक निर्देश में सात अलग-अलग ऑपकोड में से एक होना चाहिए।

DAT A B- (डेटा) - यह केवल संख्या रखता है Aऔर B। महत्वपूर्ण रूप से, एक प्रक्रिया मर जाती है जब यह एक डीएटी अनुदेश को निष्पादित करने का प्रयास करता है।
MOV A B- (चाल) - यह स्मृति स्थान की सामग्री को स्मृति स्थान Aपर ले जाता है B। यहाँ पहले और बाद का प्रदर्शन है:
```
MOV 2 1
ADD @4 #5
JMP #1 -1
```
```
MOV 2 1
JMP #1 -1
JMP #1 -1
```
ADD A B- (जोड़ने) - यह स्मृति स्थान की सामग्री कहते हैं Aस्मृति स्थान के लिए B। दोनों के दो पहले फ़ील्ड जोड़े गए हैं, और दूसरे फ़ील्ड जोड़े गए हैं।
```
ADD 2 1
MOV @4 #5
JMP #1 -1
```
```
ADD 2 1
MOV @5 #4
JMP #1 -1
```
SUB A B- (घटाना) - यह स्मृति स्थान की सामग्री को घटाता Aहै (और परिणाम को मेमोरी स्थान में संग्रहीत करता है) B।
```
SUB 2 1
MOV @4 #5
JMP #1 -1
```
```
SUB 2 1
MOV @3 #6
JMP #1 -1
```
JMP A B- (कूद) - स्थान पर कूदें A, जिसे अगले चक्र में निष्पादित किया जाएगा। Bएक संख्या होनी चाहिए, लेकिन कुछ भी नहीं है (आप इसका उपयोग जानकारी संग्रहीत करने के लिए कर सकते हैं, हालांकि)।
```
JMP 2 1337
ADD 1 2
ADD 2 3
```
कूद का मतलब है कि ADD 2 3अगले चक्र को निष्पादित किया जाएगा।
JMZ A B- (शून्य होने पर कूदें) - यदि रेखा के दोनों क्षेत्र B0 हैं, तो प्रोग्राम स्थान पर कूदता है A।
```
JMZ 2 1
SUB 0 @0
DAT 23 45
```
चूंकि निर्देश 1 के दो क्षेत्र 0 हैं, DAT कमांड को अगले मोड़ पर क्रियान्वित किया जाएगा, जिससे आसन्न मौत हो जाएगी।
CMP A B- (तुलना करें और छोड़ें यदि नहीं के बराबर) - यदि निर्देश में फ़ील्ड Aऔर Bबराबर नहीं हैं, तो अगले निर्देश को छोड़ दें।
```
CMP #1 2
ADD 2 #3
SUB @2 3
```
चूंकि निर्देश 1 और 2 के दो क्षेत्र मूल्य के बराबर हैं, इसलिए ADD कमांड को छोड़ नहीं दिया जाता है और इसे अगले मोड़ पर निष्पादित किया जाता है।

जब दो निर्देश जोड़े / घटाए जाते हैं, तो दो फ़ील्ड (A और B) जोड़े / घटाए जाते हैं। एड्रेसिंग मोड और ओपकोड को नहीं बदला जाता है।

मोड्स को संबोधित करते हुए

तीन प्रकार के एड्रेसिंग मोड हैं। एक निर्देश के दो क्षेत्रों में से प्रत्येक में इन तीन संबोधित मोड में से एक है।

तत्काल#X - Xकम्प्यूटेशन में सीधे उपयोग की जाने वाली लाइन है। उदाहरण के लिए, #0कार्यक्रम की पहली पंक्ति है। नकारात्मक रेखाएं कार्यक्रम की शुरुआत से पहले कोर में लाइनों को संदर्भित करती हैं।
```
... //just a space-filler
...
ADD #3 #4
DAT 0 1
DAT 2 4
```
यह दो DAT लाइनों के पहले को दूसरे में जोड़ देगा, क्योंकि वे क्रमशः 3 और 4 लाइनों में हैं। हालाँकि, आप इस कोड का उपयोग नहीं करना चाहेंगे, क्योंकि DAT आपके बॉट को अगले चक्र पर मार देगा।
सापेक्षX - संख्या Xवर्तमान पते के सापेक्ष लक्ष्य स्मृति पते के स्थान का प्रतिनिधित्व करती है। इस स्थान पर संख्या का उपयोग गणना में किया जाता है। यदि लाइन #35निष्पादित हो रही है और इसमें शामिल है -5, तो लाइन #30का उपयोग किया जाता है।
```
... //just a space-filler
...
ADD 2 1
DAT 0 1
DAT 2 4
```
यह दूसरी DAT लाइन को पहले जोड़ देगा।
अप्रत्यक्ष@X - संख्या Xएक सापेक्ष पते का प्रतिनिधित्व करती है। उस स्थान की सामग्री को अस्थायी रूप से एक नए रिश्तेदार पते को बनाने के लिए संख्या X में जोड़ा जाता है, जिसमें से संख्या को पुनः प्राप्त किया जाता है। यदि लाइन #35निष्पादित की जा रही है, और इसका दूसरा क्षेत्र है @4, और लाइन के दूसरे क्षेत्र में #39संख्या है -7, तो लाइन #32का उपयोग किया जाता है।
```
... //just a space-filler
...
ADD @1 @1
DAT 0 1
DAT 2 4
```
यह पहले DAT को दूसरे में जोड़ देगा, लेकिन अधिक जटिल तरीके से। पहला फ़ील्ड @ 1 है, जो उस संबंधित पते से डेटा प्राप्त करता है, जो कि पहले DAT का पहला क्षेत्र है, 0. यह उस स्थान से दूसरे रिश्तेदार पते के रूप में व्याख्या किया गया है, इसलिए 1 + 0 = 1 कुल देता है मूल अनुदेश से ऑफसेट। दूसरे क्षेत्र के लिए, @ 1 को उस सापेक्ष पते (पहले DAT के दूसरे क्षेत्र में 1) से मान मिलता है और उसी तरह से खुद को जोड़ता है। कुल ऑफसेट तब 1 + 1 = 2 है। तो, इस निर्देश को इसी तरह निष्पादित किया जाता है ADD 1 2।

प्रत्येक कार्यक्रम में 64 तक निर्देश हो सकते हैं।

जब एक दौर शुरू होता है, तो दो कार्यक्रमों को 8192 स्थानों के साथ एक मेमोरी बैंक में यादृच्छिक रूप से रखा जाता है। प्रत्येक कार्यक्रम के लिए निर्देश सूचक कार्यक्रम की शुरुआत में शुरू होता है और प्रत्येक निष्पादन चक्र के बाद बढ़ जाता है। एक बार अपने अनुदेश सूचक एक DATअनुदेश को निष्पादित करने का प्रयास करता है, तो कार्यक्रम मर जाता है ।

कोर के पैरामीटर

8192 * 8 = 65536 टिक के टाइमआउट के साथ मूल आकार 8192 है। कोर चक्रीय है, इसलिए 8195 पते को लिखना पते के लिए लिखने के समान है। सभी अप्रयुक्त पते प्रारंभिक हैं DAT #0 #0।

प्रत्येक प्रतियोगी को 64 लाइनों से अधिक नहीं होना चाहिए। पूर्णांक 32-बिट हस्ताक्षरित पूर्णांक के रूप में संग्रहीत किए जाएंगे।

पदच्छेद

प्रतियोगियों के लिए प्रोग्रामिंग को आसान बनाने के लिए, मैं पार्सर में एक लाइन-लेबल सुविधा जोड़ूंगा। किसी भी शब्द जो एक ओपकोड से पहले एक लाइन पर होते हैं, उन्हें लाइन लेबल के रूप में व्याख्या किया जाएगा। उदाहरण के लिए, tree mov 4 6लाइन लेबल है tree। यदि, कार्यक्रम में कहीं भी, एक क्षेत्र है जिसमें tree #treeया @tree, एक नंबर प्रतिस्थापित किया जाएगा। साथ ही, पूंजीकरण की अनदेखी की जाती है।

यहां एक उदाहरण दिया गया है कि लाइन लेबल कैसे प्रतिस्थापित किए जाते हैं:

labelA add labelB @labelC
labelB add #labelC labelC
labelC sub labelA @labelB

यहाँ, लेबल A, B, और C लाइन 0, 1 पर हैं, और 2. उदाहरण के #labelलेबल की लाइन संख्या के साथ प्रतिस्थापित किया जाएगा। के उदाहरण labelया @labelलेबल के सापेक्ष स्थान के साथ प्रतिस्थापित किए जाते हैं। एड्रेसिंग मोड संरक्षित हैं।

ADD 1 @2
ADD #2 1
SUB -2 @-1

स्कोरिंग

प्रतियोगियों की प्रत्येक जोड़ी के लिए, हर संभव लड़ाई की जाती है। चूंकि एक लड़ाई का परिणाम दो कार्यक्रमों के सापेक्ष ऑफसेट पर निर्भर करता है, हर संभव ऑफसेट (उनमें से लगभग 8000) की कोशिश की जाती है। इसके अलावा, प्रत्येक प्रोग्राम को प्रत्येक ऑफसेट में पहले स्थानांतरित करने का मौका है। जो कार्यक्रम इन ऑफसेट में से अधिकांश को जीतता है वह जोड़ी का विजेता है।

प्रत्येक जोड़ी के लिए जो एक योद्धा जीतता है, उसे 2 अंक दिए जाते हैं। प्रत्येक टाई के लिए, एक योद्धा को 1 अंक से सम्मानित किया जाता है।

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

नियंत्रक

नियंत्रक के लिए कोड, दो आसान उदाहरण बॉट के साथ, यहां स्थित है । चूंकि यह प्रतियोगिता (आधिकारिक सेटिंग्स का उपयोग करके चलाया जाता है) पूरी तरह से नियतात्मक है, आपके द्वारा बनाया गया लीडरबोर्ड आधिकारिक लीडरबोर्ड के समान ही होगा।

उदाहरण बॉट

यहाँ एक उदाहरण बॉट है जो भाषा की कुछ विशेषताओं को प्रदर्शित करता है।

main mov bomb #-1
     add @main main
     jmp #main 0
bomb dat 0 -1

यह बॉट "बम" के साथ बदलकर धीरे-धीरे कोर में अन्य सभी मेमोरी को मिटा देता है। चूंकि बम एक DATनिर्देश है, कोई भी कार्यक्रम जो बम तक पहुंचता है, नष्ट हो जाएगा।

दो लाइन लेबल हैं, "मुख्य" और "बम" जो संख्याओं को बदलने के लिए कार्य करते हैं। प्रीप्रोसेसिंग के बाद, प्रोग्राम इस तरह दिखता है:

MOV 3 #-1
ADD @-1 -1
JMP #0 0
DAT 0 -1

पहली पंक्ति बम को प्रोग्राम के ठीक ऊपर लाइन में कॉपी करती है। अगली पंक्ति 0 -1चाल कमांड में बम ( ) का मान जोड़ती है , और यह @एड्रेसिंग मोड के उपयोग को भी दर्शाता है। यह अतिरिक्त कदम कमांड को एक नए लक्ष्य की ओर इशारा करता है। अगला कमांड बिना शर्त कार्यक्रम की शुरुआत में वापस कूदता है।

वर्तमान लीडरबोर्ड

२४ - टर्बो
२२ - बौनाईंगनेयर
२० - हनशॉटफ़र्स्ट १war
- ड्वार्फ
१४ - स्कैनबॉम्बेर
१० - पैरानॉयड
१० - फर्स्टटीमर
१० - जेनिटर
१० - विकसित
६ - ईस्टरबनी
६ - कॉपीपास्टा
४ - छोटा
२ - स्लग

जोड़ीदार परिणाम:

Dwarf > Imp
CopyPasta > Imp
Evolved > Imp
FirstTimer > Imp
Imp > Janitor
Imp > ScanBomber
Slug > Imp
DwarvenEngineer > Imp
HanShotFirst > Imp
Turbo > Imp
EasterBunny > Imp
Paranoid > Imp
Dwarf > CopyPasta
Dwarf > Evolved
Dwarf > FirstTimer
Dwarf > Janitor
Dwarf > ScanBomber
Dwarf > Slug
DwarvenEngineer > Dwarf
HanShotFirst > Dwarf
Turbo > Dwarf
Dwarf > EasterBunny
Dwarf > Paranoid
Evolved > CopyPasta
FirstTimer > CopyPasta
Janitor > CopyPasta
ScanBomber > CopyPasta
CopyPasta > Slug
DwarvenEngineer > CopyPasta
HanShotFirst > CopyPasta
Turbo > CopyPasta
CopyPasta > EasterBunny
Paranoid > CopyPasta
Evolved > FirstTimer
Evolved > Janitor
ScanBomber > Evolved
Evolved > Slug
DwarvenEngineer > Evolved
HanShotFirst > Evolved
Turbo > Evolved
EasterBunny > Evolved
Paranoid > Evolved
Janitor > FirstTimer
ScanBomber > FirstTimer
FirstTimer > Slug
DwarvenEngineer > FirstTimer
HanShotFirst > FirstTimer
Turbo > FirstTimer
FirstTimer > EasterBunny
FirstTimer > Paranoid
ScanBomber > Janitor
Janitor > Slug
DwarvenEngineer > Janitor
HanShotFirst > Janitor
Turbo > Janitor
Janitor > EasterBunny
Janitor > Paranoid
ScanBomber > Slug
DwarvenEngineer > ScanBomber
HanShotFirst > ScanBomber
Turbo > ScanBomber
ScanBomber > EasterBunny
ScanBomber > Paranoid
DwarvenEngineer > Slug
HanShotFirst > Slug
Turbo > Slug
EasterBunny > Slug
Paranoid > Slug
DwarvenEngineer > HanShotFirst
Turbo > DwarvenEngineer
DwarvenEngineer > EasterBunny
DwarvenEngineer > Paranoid
Turbo > HanShotFirst
HanShotFirst > EasterBunny
HanShotFirst > Paranoid
Turbo > EasterBunny
Turbo > Paranoid
Paranoid > EasterBunny

नवीनतम अपडेट (टर्बो और पैरानॉयड के नए संस्करण) को एक पुराने लैपटॉप पर चलाने में लगभग 5 मिनट लगे। मैं नियंत्रक में सुधार के लिए इल्मरी करोनन को धन्यवाद देना चाहूंगा । यदि आपके पास नियंत्रक की एक स्थानीय प्रतिलिपि है, तो आपको अपनी फ़ाइलों को अपडेट करना चाहिए।

king-of-the-hill assembly

— PhiNotPi
स्रोत

यदि दो प्रतिस्पर्धी बॉट एक ही लेबल का उपयोग करने का प्रयास करते हैं तो क्या होगा?

— mbomb007

1

@ mbomb007 लेबल प्रीप्रोसेसिंग चीज हैं और गणना की जाती है क्योंकि बॉट के स्रोत फ़ाइल को पार्स किया जा रहा है। आपके लेबल किसी भी प्रतियोगी लेबल के साथ इंटरैक्ट नहीं करेंगे।

— PhiNotPi

1

@ mbomb007 ताकि प्रोग्राम ओवरलैप न हों। इसके अलावा, मैं इस संस्करण में किसी भी अधिक सुविधाओं को जोड़ने की योजना नहीं बना रहा हूं, जो माइक्रो कोर वॉर के लिए बचाते हैं।

— फीनोटपी

1

@ mbomb007 अप्रत्यक्ष रूप से उसी क्षेत्र को संदर्भित करता है जो संदर्भ (1 या 2) बना रहा है। कोई निर्देश संशोधक नहीं हैं। मैं इस चुनौती को '94 मानक से दूर नहीं कर रहा हूं।

— PhiNotPi

2

@ थ्रैक्स मैं नहीं कहने जा रहा हूं, कि आप एक सबमिशन तक सीमित नहीं हैं। सामान्य बहु-प्रस्तुत नियम लागू होते हैं (कोई टैग-टीमिंग, आदि नहीं), हालांकि कोर वार्स वैसे भी सहयोग के लिए बहुत जगह नहीं है।

— PhiNotPi

9

बौना इंजीनियर

एक नया और बेहतर बौना। अब तक जमा की गई हर चीज के खिलाफ जीत। फैंसी कोरस्टेप- स्टेपिमाइज्ड स्टेप साइज शायद यहां ओवरकिल है।

        MOV bomb    @aim
aim     MOV bomb    @-6326
        SUB step    aim
step    JMZ #0      6328
        MOV 0       1
bomb    DAT 0       3164

उल्लेखनीय विशेषताओं में तेज बमबारी लूप शामिल है जो चार चक्रों में दो बम फेंकता है, पुराने कोर वार जारगॉन में 0.5c की औसत बमबारी की गति के लिए, और यह JMZपता लगाने के लिए उपयोग किया जाता है कि बम चलाने की प्रक्रिया पूरी होने पर और बी को चालू करने का समय आ गया है। यहाँ, एक छोटा सा भूत)।

मैं 90 के दशक में कोर वार खेलता था (आप में से कुछ ने मूल गाइडबुक देखी होगी जिसे मैंने '97 में वापस लिखा था), इसलिए मैंने सोचा कि यह देखना दिलचस्प होगा कि RedCode '88 / '94 की दुनिया की कौन सी पुरानी रणनीतियाँ हो सकती हैं इस संस्करण में उपयोगी हो।

मेरे पहले विचार थे:

कोई नहीं है SPL, इस प्रकार कोई प्रतिकृतियां (और कोई छोटा सा भूत / सर्पिल नहीं है)। इससे हमलावरों को मजबूत होना चाहिए। (इसके अलावा, उन सभी फैंसी बमबारी रणनीतियों को प्रतिकृतियों से निपटने और सर्पिल लगाने के लिए डिज़ाइन किया गया है। पूरी तरह से बेकार और बेकार है। बस किसी भी DATएस के साथ बम ।)
फिर, CMPबमबारी की तुलना में स्कैनिंग अभी भी संभावित रूप से तेज है, इसलिए एक तेज स्कैनर के पास एक मौका हो सकता है।
/ अभावों की अनुपस्थिति कोर को बहुत धीमा कर देती है। वास्तव में, इस वेरिएंट में एक कोर स्पष्ट bom 1 के एक (उप-अपनाने) चरण आकार के साथ सिर्फ एक बॉम्बर है। फिर, यह स्कैनर को भी नुकसान पहुंचाता है; एक-शॉट स्कैनर → बॉम्बर रणनीति काम कर सकती है , हालांकि।
क्विकस्कैनर्स / क्विकबॉम्बर्स (एक प्रारंभिक गेम जो एक अनियंत्रित स्कैनिंग / बॉम्बिंग लूप का उपयोग करते हुए, कोर वॉर जार्गन के साथ ऐसा नहीं है) के लिए अभी भी संभावित रूप से उपयोगी हैं, लेकिन केवल लंबे कार्यक्रमों के खिलाफ (जो वे स्वयं हैं, इसलिए एक तरह का फीडबैक है) यहाँ प्रभाव)। यह कहना मुश्किल है कि क्या यह वास्तव में परेशानी के लायक है।
स्कोरिंग प्रणाली दिलचस्प है। टाई एक जीत (1/3 की बजाय पारंपरिक कोर युद्ध में) के रूप में अधिक अंक स्कोर करते हैं, जिससे उन्हें और अधिक आकर्षक बना दिया जाता है। फिर, इन नियमों के तहत बहुत सारे संबंध बनाने की संभावना वाले एकमात्र कार्यक्रम के बारे में एक छोटा सा भूत है। (इसके अलावा, डी के अभाव / वेतन वृद्धि इम्प फाटकों कठिन है, तो भी सरल imps वास्तव में बनाता करना एक टाई स्कोरिंग अगर वे अपने प्रतिद्वंद्वी जिंदा तक पहुँचने का एक मौका है।)
इसके अलावा, क्योंकि अंतिम रैंकिंग केवल इस बात पर निर्भर करती है कि आप किन कार्यक्रमों को हराते हैं, न कि आप उन्हें कितना हराते हैं, यह सामान्यवादी प्रविष्टियों का पक्ष लेता है। अपने सभी विरोधियों को केवल मुश्किल से हरा देना बेहतर है , उनमें से आधे को पूरी तरह से नष्ट कर देना और बाकी को मुश्किल से ही हारना है।
क्योंकि कोड सार्वजनिक है, हमेशा ऐसा प्रोग्राम खोजना संभव है जो किसी भी दिए गए पुराने सबमिशन को हरा सकता है - संभवतः उनमें से भी कई - भले ही वे सामान्य रूप से कितने भी अच्छे क्यों न हों। इस तरह की तरकीबें (जैसे आपके स्टेप साइज को अपने प्रतिद्वंदी से टकराने से पहले ही आपको मारना) आसानी से सस्ती लग सकती हैं, हालाँकि। और, ज़ाहिर है, लक्ष्य खिलाड़ी हमेशा विभिन्न स्थिरांक के साथ एक नया संस्करण प्रस्तुत कर सकता है।

वैसे भी, इस सब का नतीजा यह है कि मैंने फैसला किया कि मुझे या तो एक तेज़ बॉम्बर या बहुत तेज़ स्कैनर लिखने की कोशिश करनी चाहिए , और शायद उस पर क्वैश्चनर / बॉम्बर का व्यवहार करना चाहिए। उन विकल्पों में से, एक तेज़ बमवर्षक सबसे सरल और सबसे अधिक काम करने वाला था।

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

मेरे बॉम्बर को तेज करने वाली चाल अप्रत्यक्ष रूप से प्रत्येक के लिए दो बम फेंकने के लिए संबोधित कर रही है ADD। यहां बताया गया है कि यह कैसे काम करता है:

पहले चक्र पर, हम निष्पादित करते हैं MOV bomb @aim। यह bombनिर्देश को निर्देश देता है कि जहां भी aimबिंदुओं के बी-फ़ील्ड को (शुरुआत में, बिल्कुल 6326 निर्देशों को aim, या 6328 निर्देशों को पहले रखा जाए step, आप देखेंगे कि बाद में वे नंबर क्यों मायने रखते हैं)।
अगले चरण पर, हम aimनिर्देश को निष्पादित करते हैं! पहली पास पर, यह इस तरह दिखता है MOV bomb @-6326:। इस प्रकार, यह bombउस स्थान पर कॉपी हो जाता है, जहां 6326 लाइनों पर निर्देश का B- क्षेत्र खुद को इंगित करता है।

तो, इससे पहले 6326 लाइनों में क्या है aim? क्यों, यह bombसिर्फ एक चक्र से पहले रखा गया था! और हम सिर्फ चीजों को व्यवस्थित करने के लिए हुए ताकि बी-फ़ील्ड का bombएक गैर-शून्य मान हो, इसलिए पुराने बम के ऊपर नए बम की नकल नहीं की जाएगी, लेकिन कुछ दूरी पर (वास्तव में, यहां दूरी 3164 है, जो हमारे नाममात्र चरण के आकार 6328 का आधा है; लेकिन अन्य ऑफसेट काम कर सकते हैं, शायद बेहतर भी)।
अगले चक्र पर, हम अपने उद्देश्य को समायोजित करते हैं SUB step aim, जो stepनिर्देश के मूल्यों को घटाता है (जो कि ऐसा होता है कि हम जिस कूद को आगे निष्पादित करने जा रहे हैं, हालांकि यह कहीं से भी सरल हो सकता हैDAT ) aim।

(ध्यान दें यहाँ करने के लिए एक विस्तार है कि हम है एक तरह से एक-मूल्य चाहते हैं की stepकेवल बम फेंक दिया, कि, सख्ती से आवश्यक नहीं है, हालांकि शून्य हो सकता है, इसलिए है कि हम अभी भी अगले चरण पर एक ही बम फेंक देंगे भी। द्वारा पहले 3164 के लिए अपने बी-क्षेत्र के बराबर है करने के लिए अनुदेश जरूरत है, बाकी कुछ भी हो सकता है।)
अगला, यह JMZजांच कि निर्देश 6328 कदम इससे दूर है अभी भी शून्य है, और यदि हां, तो कोड के शीर्ष पर वापस कूदता है। अब, 6328 हमारे बॉम्बर का चरण आकार है, और 8 (लेकिन 16 नहीं) द्वारा विभाज्य है; इस प्रकार, यदि हम बस हर 6328 कदम पर बम फेंकते रहे, तो हम अंततः उसी स्थान पर वापस लौट आएंगे जहाँ से हमने शुरू किया था, कोर में हर आठवें निर्देश पर बमबारी हुई थी (और अतिरिक्त बमों के साथ 3163 = 6328/2 (4 (mod 8) , हम हर चौथे निर्देश मारा होगा )।

लेकिन हम 6328 निर्देश पर हमारे बमबारी रन शुरू कर दिया इससे पहलेJMZ , और, हर यात्रा पर -6328 से पीछे की ओर कदम रखा तो हम स्थान 6328 चरणों को बम से उड़ाने जा रहे हैं के बादJMZ सिर्फ एक यात्रा से पहले हम पर मारते थे JMZही। इसलिए जब इसके JMZबाद 6328 निर्देशों पर एक बम का पता चलता है , तो यह एक संकेत है कि हमने अपने आप को मारने के बिना कोर के जितना कवर किया है, और हमें खुद को मारने से पहले एक बैकअप रणनीति पर स्विच करना चाहिए।
बैकअप रणनीति के रूप में, यह सिर्फ एक सादे पुराने MOV 0 1छोटा सा भूत है, क्योंकि मैं अभी के लिए कुछ भी बेहतर नहीं सोच सकता था। जिस तरह से मैं इसे देखता हूं, अगर हमने कोर के हर चौथे स्थान पर बमबारी की है और अभी भी नहीं जीता है, तो हम शायद बहुत छोटे या बहुत रक्षात्मक कुछ लड़ रहे हैं, और साथ ही बस एक टिक के लिए जीवित रहने और बसने की कोशिश कर सकते हैं। यह ठीक है, क्योंकि इस तरह के छोटे या रक्षात्मक कार्यक्रम आम तौर पर किसी भी चीज को मारने में बहुत अच्छे नहीं होते हैं, और इसलिए भी अगर हम केवल कुछ झगड़े जीतते हैं, तो हम शायद अभी भी आगे निकल आएंगे।

Ps। यदि कोई अन्य व्यक्ति ऐसा चाहता है, तो यहां PhiNotPi के टूर्नामेंट कोड का मेरा थोड़ा सुधार हुआ है । यह लगभग दो बार उपवास के रूप में है, पुराने युद्ध परिणामों को बचाता है ताकि आपको उन्हें फिर से चलाने की आवश्यकता न हो, और मुझे लगता है कि युद्ध के परिणाम की गणना में एक मामूली बग ~~होने को ठीक करता है~~ । परिवर्तनों को मेनोटी संस्करण में PhiNotPi द्वारा विलय कर दिया गया है । धन्यवाद!

— इल्मरी करोनें
स्रोत

1

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

— mbomb007

9

ग्राफ देखें

यह डिबगिंग टूल के रूप में उपयोग किया जा सकता है। यह कोर प्रदर्शित करता है और खिलाड़ी का स्थान दिखाता है। इसका उपयोग करने के लिए आपको इसे कोड से कॉल करना होगा। मैंने एक मोडिफ़ाइड भी प्रदान किया है जो Game.javaकि ग्राफ़ व्यू को स्वचालित रूप से प्रदर्शित करता है।

PhiNotPi और Ilmari Karonen ने हाल ही में नियंत्रक को बदल दिया है। इल्मरी करोनन इस स्थान पर अपडेटेड गेम व्यू प्रदान करने के लिए पर्याप्त हैं ।

import javax.swing.*;
import java.awt.*;

public class GameView extends JComponent{

    final static Color[] commandColors = new Color[]{
            Color.black, //DAT
            Color.blue,  //MOV
            Color.blue,  //ADD
            Color.blue,  //SUB
            Color.blue,  //JMP
            Color.blue,  //JMZ
            Color.blue,  //CMP
    };

    final static Color[] specialColors = new Color[]{
            new Color(0,0,0),
            new Color(190, 255, 152),
            Color.yellow,
            new Color(0, 93, 14),
            new Color(96, 92, 4),
            new Color(0, 93, 14),
            new Color(96, 92, 4),
            new Color(0, 93, 14),
            new Color(96, 92, 4)
    };

    final static Color playerOneColor = Color.green;
    final static Color playerTwoColor = Color.white;

    final Game game;

    int playerOneLocation;
    int playerTwoLocation;

    final static int width = 128;
    final static int height = 64;

    public GameView(Game game) {
        this.game = game;
    }

    @Override
    public void paint(Graphics g) {
        int pixelWidth = getSize().width;
        int pixelHeight = getSize().height;
        if (width > pixelWidth){
            pixelWidth = width;
            setSize(width, pixelHeight);
        }
        if (height > pixelHeight){
            pixelHeight = height;
            setSize(pixelWidth, height);
        }
        int squareWidth = Math.min(pixelWidth / width, pixelHeight / height);
        for (int x = 0; x < squareWidth * width; x += squareWidth){
            for (int y = 0; y < squareWidth * height; y += squareWidth){
                int index = (y / squareWidth) * width + (x / squareWidth);
                Color color = commandColors[game.core[index][0]];
                if (game.coreData[index] != 0){
                    color = specialColors[game.coreData[index]];
                }
                if (index == playerOneLocation){
                    color = playerOneColor;
                }
                if (index == playerTwoLocation){
                    color = playerTwoColor;
                }
                g.setColor(color);
                g.fillRect(x, y, squareWidth, squareWidth);
            }
        }
    }

    public void setLocations(int p1loc, int p2loc){
        this.playerOneLocation = p1loc;
        this.playerTwoLocation = p2loc;
    }
}

संशोधित गेम.जावा:

import javax.swing.*;
import java.util.Random;
import java.util.ArrayList;
import java.util.Arrays;
/**
 * This runs a game of Core Wars between two players.  It can be called mutiple times.
 * 
 * @author PhiNotPi 
 * @version 3/10/15
 */
public class Game
{
    final Player p1;
    final Player p2;
    final int coreSize;
    final int coreSizeM1;
    final int maxTime;
    final int debug;
    public int[][] core;
    public int[] coreData; //Used in debugging.
    int offset1;
    int offset2;
    Random rand;
    ArrayList<int[]> p1code;
    ArrayList<int[]> p2code;
    int p1size;
    int p2size;
    GameView gameView;
    int time = 1000000; //Time in nanoseconds between frames
    public Game(Player A, Player B, int coreSize, int maxTime, int debug)
    {
        p1 = A;
        p2 = B;

        coreSize--;
        coreSize |= coreSize >> 1;
        coreSize |= coreSize >> 2;
        coreSize |= coreSize >> 4;
        coreSize |= coreSize >> 8;
        coreSize |= coreSize >> 16;
        coreSize++;

        this.coreSize = coreSize;
        this.coreSizeM1 = coreSize - 1;
        this.maxTime = maxTime / 2;
        this.debug = debug;
        core = new int[coreSize][5];
        rand = new Random();
        p1code =  p1.getCode();
        p1size = p1code.size();
        p2code =  p2.getCode();
        p2size = p2code.size();
        if (debug == 1){
            gameView = new GameView(this);
            JFrame frame = new JFrame("Game");
            frame.add(gameView);
            frame.setVisible(true);
            frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
            frame.setSize(128, 64);
            coreData = new int[coreSize];
        }
    }

    public int runAll()
    {
        int sum = 0;
        for(int i = 0; i < coreSize - p1size - p2size; i++)
        {
            sum += run(i) - 1;
        }
        if(sum > 0)
        {
            return 1;
        }
        if(sum < 0)
        {
            return -1;
        }
        return 0;
    }

    public int run()
    {
        return run(rand.nextInt(coreSize - p1size - p2size + 1));
    }

    public int run(int deltaOffset)
    {
        core = new int[coreSize][5];
        //offset1 = rand.nextInt(coreSize);
        offset1 = 0;
        for(int i = 0; i != p1size; i++)
        {
            //System.arraycopy(p1.getCode().get(i), 0, core[(offset1 + i) % coreSize], 0, 5 );
            int[] line = p1code.get(i);
            int loc = (offset1 + i) & coreSizeM1;
            core[loc][0] = line[0];
            core[loc][1] = line[1];
            core[loc][2] = line[2];
            core[loc][3] = line[3];
            core[loc][4] = line[4];
            if (debug != 0){
                coreData[loc] = 1;
            }
        }
        offset2 = offset1 + p1size + deltaOffset;
        for(int i = 0; i != p2size; i++)
        {
            //System.arraycopy(p2.getCode().get(i), 0, core[(offset2 + i) % coreSize], 0, 5 );
            int[] line = p2code.get(i);
            int loc = (offset2 + i) & coreSizeM1;
            core[loc][0] = line[0];
            core[loc][1] = line[1];
            core[loc][2] = line[2];
            core[loc][3] = line[3];
            core[loc][4] = line[4];
            if (debug != 0){
                coreData[loc] = 2;
            }
        }

        int p1loc = offset1 & coreSizeM1;
        int p2loc = offset2 & coreSizeM1;
        for(int time = 0; time != maxTime; time++)
        {
            if(debug != 0)
            {
                //printCore(p1loc,p2loc);
                //System.out.println("p1loc " + p1loc);
                //System.out.println("offset " + offset1);
                gameView.setLocations(p1loc, p2loc);
                gameView.repaint();
                try {
                    Thread.sleep(time / 1000000, time % 1000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            if(core[p1loc][0] == 0)
            {
                return 0;
            }
            p1loc = execute(p1loc, offset1, 1);

            if(debug != 0)
            {
                //printCore(p1loc,p2loc);
                //System.out.println("p2loc " + p2loc);
                //System.out.println("offset " + offset2);
                gameView.setLocations(p1loc, p2loc);
                gameView.repaint();
                /*try {
                    Thread.sleep(time);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
            if(core[p2loc][0] == 0)
            {
                return 2;
            }
            p2loc = execute(p2loc, offset2, 2);

        }
        return 1;
    }
    public int execute(int ploc, int offset, int player)
    {
        int line1 = offset + core[ploc][3];
        if(core[ploc][1] != 0)
        {
            line1 += ploc - offset;
        }
        if(core[ploc][1] == 2)
        {
            line1 += core[line1 & coreSizeM1][3];
        }
        int line2 = offset + core[ploc][4];
        if(core[ploc][2] != 0)
        {
            line2 += ploc - offset;
        }
        if(core[ploc][2] == 2)
        {
            line2 += core[line2 & coreSizeM1][4];
        }
        line1 = line1 & coreSizeM1;
        line2 = line2 & coreSizeM1;
        int opcode = core[ploc][0];
        ploc = (ploc + 1) & coreSizeM1;
        //String opDescription = "";
        if(opcode == 1)
        {
            core[line2][0] = core[line1][0];
            core[line2][1] = core[line1][1];
            core[line2][2] = core[line1][2];
            core[line2][3] = core[line1][3];
            core[line2][4] = core[line1][4];
            if (debug != 0) {
                coreData[line2] = player + 2;
            }
            return ploc;
            //opDescription = "Moved from " + line1 + " to " + line2;
        }
        if(opcode == 2)
        {
            core[line2][3] += core[line1][3];
            core[line2][4] += core[line1][4];
            if (debug != 0) {
                coreData[line2] = player + 4;
            }
            return ploc;
            //opDescription = "Added " + line1 + " to " + line2;
        }
        if(opcode == 3)
        {
            core[line2][3] -= core[line1][3];
            core[line2][4] -= core[line1][4];
            if (debug != 0) {
                coreData[line2] = player + 6;
            }
            return ploc;
                //opDescription = "Subtracted " + line1 + " to " + line2;
        }
        if(opcode == 4)
        {
            ploc = line1;
            return ploc;
                //opDescription = "Jumped to " + line1;
        }
        if(opcode == 5)
        {
                if(core[line2][3] == 0 && core[line2][4] == 0)
                {
                    ploc = line1;
                    //opDescription = "Jumped to " + line1;
                }
                else
                {
                    //opDescription = "Did not jump to " + line1;
                }
                return ploc;
        }
        if(opcode == 6)
        {
            if(core[line1][3] == core[line2][3] && core[line1][4] == core[line2][4])
            {
                //opDescription = "Did not skip because " + line1 + " and " + line2 + " were equal.";
            }
            else
            {
                ploc = (ploc + 1) & coreSizeM1;
                //opDescription = "Skipped because " + line1 + " and " + line2 + " were not equal.";
            }
            return ploc;
        }
        if(debug != 0)
        {
            //System.out.println(opDescription);
        }
        return ploc;
    }
    /*public void printCore(int p1loc, int p2loc)
    {
        int dupCount = 0;
        int[] dupLine = new int[]{0,0,0,0,0};
        for(int i = 0; i < core.length; i++)
        {
            int[] line = core[i];
            if(Arrays.equals(line, dupLine) && i != p1loc && i != p2loc)
            {
                if(dupCount == 0)
                {
                    System.out.println(Player.toString(line));
                }
                dupCount++;
            }
            else
            {
                if(dupCount == 2)
                {
                    System.out.println(Player.toString(dupLine));
                }
                else if(dupCount > 2)
                {
                    System.out.println("    " + (dupCount - 1) + " lines skipped.");
                }
                System.out.println(Player.toString(line));
                if(i == p1loc)
                {
                    System.out.print(" <- 1");
                }
                if(i == p2loc)
                {
                    System.out.print(" <- 2");
                }
                dupLine = line;
                dupCount = 1;
            }
        }
        if(dupCount == 2)
        {
            System.out.println(Player.toString(dupLine));
        }
        else if(dupCount > 2)
        {
            System.out.println("    " + (dupCount - 1) + " lines skipped.");
        }
    }*/
}

— नंबर एक
स्रोत

ऐसा लगता है कि आपने प्लेयर को भी संशोधित किया है। मुझे मिलता है

./Game.java:275: error: method toString in class Object cannot be applied to given types;                     System.out.println(Player.toString(line));                                              ^   required: no arguments   found: int[]

— एएसएचली

@AShelly इस बारे में क्षमा करें। मुझे printCore()विधि की टिप्पणी करनी चाहिए ।

— द नम्बरनॉ

9

टर्बो

main   add three target
test   jmz -1 @target
bomb   mov three @target
       sub j1 target 
       mov jump @target
       sub j1 target 
       mov copy @target
       sub j1 target
two    mov decr @target
j1     jmp @target 1
target dat -8 -8   
decr   sub #two 3
copy   mov 2 @2
jump   jmp -2 0
three dat -9 -9

मेरा दूसरा कभी कोरवार प्रयास। बौना हरा करने के लिए डिज़ाइन किया गया। डेटा के लिए 3 से स्कैन करता है, फिर हर 2 में एक बम डालता है। प्रत्येक चरण केवल 3 निर्देशों में चलता है, इस उम्मीद में कि बौने के बम से चूक जाते हैं।

नया टर्बो ++ : अब बढ़ाया गया। यह पिछड़ों को स्कैन करता है जब तक कि यह डेटा नहीं ढूंढता है, फिर खुद को वहां ले जाता है, फिर पीछे की ओर बम लगाता है। उम्मीद यह है कि यह कदम या तो प्रतिद्वंद्वी को पछाड़ देता है, या पहले से बमबारी करने वाली जगह पर है और इसलिए सुरक्षित (ईश) है।

... और इसे संपादित करने के लिए इसे और अधिक संयम से स्कैन करने से यह हर किसी को हरा देता है!

— AShelly
स्रोत

सिर्फ बौने से बहुत अधिक हरा लगता है। बधाई हो! मुझे लगता है कि आप तीसरे स्थान पर पहुंच सकते हैं यदि आप केवल Imp को हरा सकते हैं।

— इल्मरी करोनें

मैंने इसे अपडेट किया, लेकिन यह वास्तव में पिछले एक से काफी बड़ा विकास है। क्या मुझे इसके बजाय एक नई प्रविष्टि बनानी चाहिए थी?

— आशुली

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

— इल्मरी करोनें

बहुत बढ़िया ;)। तुम अब हरा करने वाले हो!

— मारा

8

बौना आदमी

एक सामान्य और सरल कार्यक्रम जो एक बौना फेंकने वाले पत्थर का प्रतिनिधित्व करता है। यह DATहर चार पते पर एक निर्देश देता है।

add 2 3
mov 2 @2
jmp -2 #4
dat #0 #4

संपादित करें: पते को ठीक करता है। जाहिरा तौर पर संबोधन मोड ओपी से जुड़ी कल्पना से अलग हैं।

— mbomb007
स्रोत

मुझे लगता है कि यह पहली पंक्ति के लिए "# 3 3 जोड़ें" है, है ना?

— मारा

@ हिट नोप। मैं हर 4 वें पते पर हिट करना चाहता हूं। मैं उपयोग कर सकता था add 3 3, लेकिन फिर यह जोड़ने के बजाय प्रत्येक लूप को दोगुना कर देगा, और यह उपयोगी नहीं होगा। #4एक तात्कालिक है, इसलिए यह वर्तमान पते के बाद के 4पते में 2 मान के लिए संख्या जोड़ता है 3।

— mbomb007

मुझे लगता है कि आप #चुनौती में एड्रेसिंग मोड की गलत व्याख्या कर रहे हैं । जैसा कि कल्पना में कहा गया है, मैंने #एड्रेसिंग मोड में बदलाव किया ।

— PhiNotPi

आपको इस तरह से जाना चाहिए: "2 3 mov 2 @ 2 jmp -2 4 dat 0 4"

— Hit

सही व्यवहार के साथ यह भी पराजित हो गया

— Hit

7

विकसित

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

इसका अध्ययन करने के बाद, मैंने पाया कि यह सिर्फ एक छोटा सा अशुद्ध गार्ड है। DATनिर्देशों के साथ दुश्मनों पर बमबारी करने के बजाय , यह दुश्मनों के कोड को बदल देता है। यह हर चार रजिस्टरों के बजाय हर दो रजिस्टरों को बम बनाता है। पर्याप्त समय को देखते हुए, यह निस्संदेह खुद को नष्ट कर देगा।

MOV -2 #-1
MOV #4 -9
SUB -5 #6
MOV #1 1
MOV #-6 #4
SUB @8 @7
JMP -3 @4
DAT #-4 8
JMP -1 9
JMP 5 #-10
CMP @-1 #0
SUB 3 #-10
JMP @10 #-9
JMZ #1 10
MOV #3 2
ADD @9 @-3
CMP #-3 @7
DAT @0 @-2
JMP @-7 #6
DAT @-8 -6
MOV @0 #9
MOV #2 1
DAT @6882 #-10
JMP @3 4
CMP @8 2
ADD -7 @11
ADD @1 #-9
JMZ @-5 7
CMP 11 5526
MOV @8 6
SUB -6 @0
JMP 1 11
ADD @-3 #-8
JMZ @-14 @-5
ADD 0 @-8
SUB #3 @9
JMP #-1 5
JMP #9 @1
CMP -9 @0
SUB #4 #-2
JMP #-8 5
DAT -1 @-10
MOV 6 #2
CMP @-11 #-14
ADD @4 @-3
MOV @5 #-6
SUB -3 -2
DAT @-10 #-1
MOV #-13 #-6
MOV #1 5
ADD 5 #-5
MOV -8 @-1
DAT 0 10
DAT #5 #7
JMZ 6 -5
JMZ -12 -11
JMP 5 @-7
MOV #7 -3
SUB #-7 @-3
JMP -4 @-11
CMP @-5 #-2
JMZ @-1 #0
ADD #3 #2
MOV #5 @-6

— नंबर एक
स्रोत

1

फिर कहाँ से मिला?

— अप्रैल को PyRulez

4

@PyRulez यह आनुवंशिक एल्गोरिथ्म के माध्यम से उत्पन्न कंप्यूटर है।

— TheNumberOne

1

ऐसा लगता है कि निष्पादन वास्तव में लाइन # 6 की तुलना में आगे नहीं बढ़ता है, क्योंकि वहां यह कार्यक्रम में वापस कूदता है। मेरा मानना है कि यह कारण है कि यह सफल होता है कि उसके प्रतिद्वंद्वियों की तुलना में अधिक चाल / पाश हैं।

— PhiNotPi

6

पहलीबार करनेवाला

यदि यह काम करता है, तो इसे कोर की शुरुआत में स्थिति लेने और एक दोष बनाने की कोशिश करनी चाहिए

main MOV 5 #0
     ADD #data #main
     CMP #main #max
     JMP #0 0
     JMP #main 0
     MOV #data #100
     ADD #data -1
     JMP -2 0
data DAT 1 1
max  DAT 8 3

— Thrax
स्रोत

यह उस तरह से बहुत काम नहीं करता है जिस तरह से मुझे लगता है कि आपने इसे ग्रहण किया है: आपके कार्यक्रम#0 की शुरुआत को संदर्भित करता है (जैसे कि जैसा है ), कोर की शुरुआत के लिए नहीं (जो वास्तव में वैसे भी एक सार्थक अवधारणा नहीं है - कोर है परिपत्र, आपका कोड यह नहीं बता सकता है कि यह कहां से शुरू होता है या समाप्त होता है)। क्या होता है कि आपका पहला निर्देश ( ) अपने आप से अधिलेखित हो जाता है , जिसके बाद आपका कोड प्रभावी रूप से 0.25c (= चार चक्रों में एक निर्देश) फॉरवर्ड कोर स्पष्ट हो जाता है। #mainmainMOV #data #100

— इल्मरी करोनें

@ इल्मारिकारोन ओह, स्पष्टीकरण के लिए धन्यवाद। मैंने #0कोर की शुरुआत के लिए गलती की । 5 पहले निर्देश तो पूरी तरह से बेकार हैं।

— थ्रक्स

6

CopyPasta

एक CoreWar में कभी भी भाग नहीं लिया, यह सरल कार्यक्रम सिर्फ खुद को कॉपी-पेस्ट करने और फिर कॉपी निष्पादित करने का प्रयास कर रहा है। यह सही व्यवहार नहीं हो सकता है, कृपया मुझे बताएं कि क्या यह मामला है।

यह बहुत शांतिवादी है और वास्तव में जीत नहीं सकता है।

MOV 6 0
MOV @-1 @-1
CMP @-2 3
JMP 4242 0
SUB -3 -4
JMP -4 0
DAT 0 4244

— मारो
स्रोत

यह वर्तमान संपादन संभवतः अगले लीडरबोर्ड अपडेट में नहीं होने वाला है (मैं अभी टूर्नामेंट चला रहा हूं)। पुराने संस्करण, हालांकि, (छोटे मूल आकार) प्रारंभिक परिणाम जीत रहा था।

— PhiNotPi

ठीक है :) पुराना संस्करण लूप 1 से बाहर नहीं जाता है, यह वास्तव में वांछित व्यवहार नहीं है, मैं इसे ठीक करने की कोशिश कर रहा हूं।

— मारा

वर्तमान संस्करण टूटा हुआ लगता है। मुझे पता नहीं क्यों, अभी तक।

— PhiNotPi

1

मैंने डिबगिंग टूल को फिर से चालू किया है, इसलिए अब मैं समस्या का निदान कर सकता हूं। क्या हो रहा है कि कार्यक्रम केवल खुद के दूसरे छमाही (शुरू में JMP loop 0) की प्रतिलिपि बनाता है । फिर, जब यह कूदता है जहां कॉपी की शुरुआत होनी चाहिए, यह सिर्फ खाली जगह है और यह खो देता है।

— फीनोटपी

2

कृपया मेरी पिछली (अब हटाई गई) टिप्पणी को अनदेखा करें; मैंने आपके कोड के एक गलत संस्करण का परीक्षण किया था (विडंबना यह है कि कॉपी-पेस्ट की गलती के कारण), यही कारण है कि यह मेरे लिए इतना खराब काम करता था।

— इल्मरी करोनें

6

चौकीदार

यह जांचना चाहिए कि क्या निम्नलिखित पते खाली हैं और यदि यह उन्हें साफ नहीं करता है (इस प्रकार, उम्मीद है, प्रतिद्वंद्वी बॉट को मिटाकर)।

संपादित करें: यह नया संस्करण जल्दी होना चाहिए (अब जब मैंने JMZकमांड और @संदर्भ को सही ढंग से समझा था )।

JMZ 2 6
MOV 4 @-1
ADD 2 -2
JMP -3 0
DAT 0 1
DAT 0 0

— plannapus
स्रोत

क्या चौकीदार पहली JMZ के साथ आत्महत्या नहीं कर रहा है? यह कम से कम JMZ 2 होना चाहिए। 8 @ का उपयोग करके आप केवल एक में दो ऐड को कम कर सकते हैं। कुछ इस तरह से: "JMZ 2 @ 5 MOV 5 @ 4 ADD 2 3 JMP -3 0 DAT 0 1 DAT 0 2 DAT 0 0" (अप्रकाशित)

— मारो

@ यह नहीं कूदता है, क्योंकि वहाँ से पता 2 है ADD 3 -2, लेकिन आप सही हैं कि उसे इसे बदलना चाहिए, मुझे लगता है।

— mbomb007

हाँ मैं अनुदेश पढ़ने में भूलना के लिए JMZऔर सोचा JMZ A Bकी जाँच की गई थी Aऔर करने के लिए कूद Bअगर 0 जब जाहिरा तौर पर यह विपरीत है। ध्यान देने के लिए धन्यवाद क्योंकि मैं नहीं था :)

— प्लेनैपस

5

ScanBomber

संकलन करने से पहले मेरी टिप्पणियों को हटा दें। थोड़ी देर के लिए स्कैन करता है, फिर जब यह एक कार्यक्रम पाता है तो बम होता है। यह शायद अभी भी मेरे बौने को खो देगा, हालांकि।

scan add #eight #range  ; scan
jmz #scan @range
sub #six #range
fire mov #zero @range   ; bombs away! (-6)
add #two #range
mov #zero @range
add #two #range
mov #zero @range
add #two #range
mov #zero @range        ; (+0)
add #two #range
mov #zero @range
add #two #range
mov #zero @range
add #two #range
mov #zero @range
add #two #range
mov #zero @range        ; (+8)
range jmp #scan 6
two dat 0 2
six dat 0 6
zero dat 0 0
eight dat 0 8

— mbomb007
स्रोत

ओपी #ने कल्पना की तुलना में पूरी तरह से अलग तरीके से परिभाषित किया (वह लिंक जिसे वह जुड़ा हुआ है), मैंने अभी तक इसके लिए इस कार्यक्रम को ठीक नहीं किया है।

— mbomb007

@ TheBestOne मुझे लगता है कि मैंने इसे ठीक किया। क्या यह ऐसा लगता है जैसे यह अब समझ में आता है? या क्या मुझे #हर संदर्भ से पहले डालने की आवश्यकता है zero? हाँ, मुझे लगता है कि मुझे जरूरत है ...

— mbomb007

यह अब अच्छी तरह से काम करता है। यह बौना और छोटा सा भूत को छोड़कर हर बॉट को हरा देता है।

— TheNumberOne

@BestOne बौना बहुत छोटा है और केवल संभावित कार्यक्रम प्लेसमेंट के 50% में पता लगाया जाएगा। यह केवल इम्पी के लिए हारता है क्योंकि यह मेमोरी की संपूर्णता के चारों ओर जाने के बाद खुद को बम बनाता है।

— mbomb007

5

हान शॉट फर्स्ट (v2)

मुझे लगा कि प्रतियोगिता कुछ और विविधता का उपयोग कर सकती है, इसलिए यहां मेरी दूसरी प्रविष्टि है: एक-शॉट CMPस्कैनर।

ये है संस्करण 2 है , बेहतर एंटी-इम्पी डिफेंस के साथ - यह अब इम्पी को हरा सकता है, अगर केवल एक बिंदु से। यह अभी भी Dwarven Engineer को खो देता है, लेकिन अब तक बाकी सब चीज़ों को हरा देता है, और वर्तमान में इसे पहले स्थान पर रखता है।

scan    ADD bomb    aim
aim     CMP 17      12
        JMZ scan    #-3
loop    MOV bomb    @aim
        ADD step    aim
step    JMP loop    #2
bomb    DAT 10      10

यह आस-पास के मुख्य स्थानों की तुलना में 10-चरणों के अंतराल पर 5 चरणों की तुलना करके काम करता है, जब तक कि इसमें अंतर नहीं मिलता। जब यह होता है, तो यह 2-चरण के अंतराल पर बमों को फेंकना शुरू कर देता है जब तक कि यह अपने प्रतिद्वंद्वी को मारता नहीं है या खुद तक पहुंचने के लिए कोर के चारों ओर छोरों को मारता है।

यदि स्कैन नहीं करता है कुछ और मिलता है, तो यह अंततः लूप करेगा और अपना कोड ढूंढेगा और उस पर हमला करेगा। यह आत्मघाती होगा, लेकिन भाग्यशाली संयोग के लिए कि पहले बम की aimरेखा पर वर्ग भूमि , अगले बम को 12 पदों (सामान्य 2 के बजाय) से नीचे फेंक दिया, आसानी से कोड को लंघन। (यह 50% संभावना के साथ भी होता है यदि स्कैन कुछ पाता है, लेकिन प्रतिद्वंद्वी को मारने में विफल रहता है।) चूंकि कोर का आकार दो में से एक है, इसलिए यह तब भी होता रहेगा जब बम चलाने के चारों ओर छोरों, एक की आवश्यकता को समाप्त कर देता है आगे की रणनीति।

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

— इल्मरी करोनें
स्रोत

4

छोटा सा भूत

MOV 0 1

कार्यक्रम के माध्यम से बस इंच।

— नंबर एक
स्रोत

4

काउंटर

     mov    ones    @-1024
     mov    from    -3
     mov    here    -3
loop mov    @-5 @-4
     add    ones  -5
     jmz    -17 -6
     add    ones  -8    
     jmp    loop    42
ones dat    1   1
from dat    2   2
here dat    -11 -11

स्मृति स्थान के माध्यम से पीछे की ओर क्रॉल। कभी-कभी दूर तक बम फेंकता है।

— AShelly
स्रोत

3

ईस्टर बनी

वह पीछे की ओर मुडकर आनंद लेता है :)

loop mov 0 -10
     add data loop
     cmp -7 data
     jmp -13 0
     jmp loop 0
data dat 1 1

— नंबर एक
स्रोत

3

पैरानॉयड

एक कॉपी-पास्ता की तरह लेकिन यह जांच करेगा कि क्या कोड को बम से संशोधित किया गया है। यदि ऐसा है तो यह पिछले बौने की नकल करता है और इसे निष्पादित करता है। अगर मैं GameView को फिर से बनाने का प्रबंधन करता हूं तो मैं कुछ स्थिरांक बदलने की कोशिश करूंगा।

copy    MOV data copy
loop    MOV @-1 @-1
    CMP @copy end
out JMP check 0
    SUB loop copy
    JMP loop 0
data    DAT 0 4109
check   MOV data copy
loop2   CMP @copy @copy
    JMP ok 0
    MOV aah 2
ok  CMP @copy end
    JMP 4098 0
    SUB loop copy
    JMP loop2 0
panic   MOV end copy
    MOV jump out
    JMP loop 0
jump    JMP 4124 0
dwarf   ADD 2 bomb
    MOV bomb @bomb
    JMP dwarf 4
bomb    DAT 0 4
aah JMP 3 0
end DAT 19 4127

— मारो
स्रोत

ठीक है, वास्तव में यह काम कर रहा है और मैं बस चारों ओर गड़बड़ था, नए रन के लिए धन्यवाद;)

— मारा

नैनो कोर वॉर

पृष्ठभूमि

निर्देश सेट

opcodes

मोड्स को संबोधित करते हुए

कोर के पैरामीटर

पदच्छेद

स्कोरिंग

नियंत्रक

उदाहरण बॉट

वर्तमान लीडरबोर्ड

बौना इंजीनियर

ग्राफ देखें

टर्बो

बौना आदमी

विकसित

पहलीबार करनेवाला

CopyPasta

चौकीदार

ScanBomber

हान शॉट फर्स्ट (v2)

छोटा सा भूत

काउंटर

ईस्टर बनी

पैरानॉयड