रॉकेट बॉट्स KOTH

11

रॉकेट बॉट

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

गेमप्ले

बॉट

गेमप्ले 10x15 ग्रिड पर होता है। आपका बॉट नीचे के किनारे पर स्थित है, और ग्रिड के स्पॉट 6,7 और 8 में तीन स्लॉट हैं। आपका प्रतिद्वंद्वी ग्रिड के शीर्ष पर स्थित है, जिसमें तीन स्लॉट सीधे आपके विपरीत हैं।

रॉकेट्स

इनमें से किसी भी स्लॉट से, आप रॉकेट को आग लगा सकते हैं, यह मानते हुए कि स्लॉट नष्ट नहीं हुआ है। एक रॉकेट में दिशाओं की एक सूची होती है जो इसे बनाते समय दी जाती है, और एक बार इन दिशाओं को निकाल देने के बाद इसे बदला नहीं जा सकता है। प्रत्येक मोड़, रॉकेट सूची के शीर्ष का उपभोग करेगा, और उस दिशा में आगे बढ़ेगा। रॉकेट एक साथ चलते हैं। यदि दो रॉकेट एक ही टाइल में समाप्त हो जाते हैं, तो वे दोनों फट जाएंगे। यदि कोई रॉकेट कमांड से बाहर निकलता है, तो उसमें विस्फोट होगा। यदि कोई रॉकेट ईंधन से बाहर निकलता है, तो 100 चालों के बाद, वह फट जाएगा। जब कोई रॉकेट फटता है, तो वह 5 टर्न के लिए उस टाइल में बना रहता है, जिससे कोई भी अन्य रॉकेट वहां तक ​​पहुंच जाता है।

नोट: एक साथ आंदोलन के कारण, दो रॉकेट एक दूसरे को विस्फोट किए बिना पारित कर सकते हैं, जब तक कि वे दोनों एक ही टाइल में एक मोड़ को समाप्त नहीं करते।

लक्ष्य

प्रत्येक मैच का लक्ष्य आपको अपने विरोधियों के स्लॉट को नष्ट करना है जबकि आपको जीवित रखना है। एक रॉकेट को आपके पास मौजूद किसी भी लाइव स्लॉट से निकाल दिया जा सकता है, और इसे निकाल दिए जाने से पहले आपके द्वारा निर्दिष्ट मार्ग दिया जाता है। आप हर दूसरे मोड़ पर एक रॉकेट फायर करते हैं, इससे पहले कि आप एक और फायर कर सकें, रॉकेट दो बार चलेंगे। एक द्वंद्व 200 बारी के लिए रहता है, या जब तक कि एक बॉट स्लॉट सभी नष्ट नहीं हो जाते।

स्कोरिंग

मैच के अंत में, आपके पास प्रत्येक लाइव स्लॉट के लिए एक अंक मिलता है, और आपके द्वारा नष्ट किए गए प्रत्येक प्रतिद्वंद्वी स्लॉट के लिए एक बिंदु। इसका मतलब है कि यह एक शून्य-राशि का खेल है, और प्रत्येक मैच में 6 अंक दिए जाएंगे।

एक राउंड रॉबिन चलाया जाएगा ताकि प्रत्येक बॉट एक-दूसरे को एक बार बॉट का सामना करें। यदि कोई बॉट RNG का उपयोग करता है, तो प्रत्येक मैचअप के बजाय 1000 युगल होंगे।

कार्यान्वयन

प्रतियोगिता के लिए कोड यहां पाया जा सकता है: https://github.com/Cain93/RocketBots

प्रत्येक जमा को Botकक्षा का विस्तार करना चाहिए । आपको fireRocketविधि को ओवरराइड करना चाहिए । इस पद्धति से रॉकेट का ग्रिड सरणी प्राप्त होता है Rocket[][], जो गेमबोर्ड का प्रतिनिधित्व करता है। तुम हमेशा स्पॉट पर स्लॉट के साथ, ग्रिड के निचले भाग में स्थित हैं [-1][6], [-1][7], [-1][8]। ग्रिड पर, अप्रकाशित स्पॉट के साथ प्रतिनिधित्व किया जाएगा null। यदि एक टाइल में एक रॉकेट मौजूद है, तो आप यह पहचान सकते हैं कि यह किस disक्षेत्र तक पहुंच से संबंधित है । "^" आपका रॉकेट है, और "v" आपके विरोधी हैं।

आपको इंटेगर के लिंक्डलिस्ट को वापस करना होगा जो आपके रॉकेट के लिए निर्देश देता है। ऊपर जाने के लिए, 0. का उपयोग करें। ऊपर और दाएं जाने के लिए, 1 का उपयोग करें, बस दाएं, 2 का उपयोग करें, आदि सभी ऊपर और बाएं के लिए 7 तक। रॉकेट उस क्रम में आगे बढ़ेगा, जिस पर आप इंटेगर को धक्का देते हैं। उदाहरण के लिए, निम्नलिखित कोड रॉकेट को ऊपर की ओर कुछ मोड़ देगा, ज़िग-ज़ैग कुछ मोड़ और फिर विस्फोट करेगा।

LinkedList<Integer> moves = new LinkedList<Integer>();

moves.push(0);
moves.push(0);
moves.push(0);
moves.push(1);
moves.push(7);
moves.push(1);
moves.push(7);

रॉकेट को आग लगाने के लिए किस स्लॉट को बदलने के लिए, curSlotफ़ील्ड को बदलें । 0 आपका सबसे बाईं ओर का स्लॉट है, और 2 आपका सबसे दाहिना है। यह जांचने के लिए कि क्या कोई स्लॉट नष्ट हो गया है, का उपयोग करें getSlot(int slotNumber)।

यदि कोई रॉकेट किसी स्लॉट पर टर्न समाप्त करता है, तो वह स्लॉट नष्ट हो जाएगा। आपको रॉकेट को मैन्युअल रूप से विस्फोट करने की आवश्यकता नहीं है।

नोट: रॉकेट उस स्थान पर स्थित है, जहां से निकाल दिया गया है, लेकिन टकरावों के मूल्यांकन से पहले एक बार चलेंगे। इसलिए यदि आप स्लॉट 0 से एक रॉकेट फायर करते हैं, और पहली चाल सही (2) है, तो आप अपने स्वयं के मध्य स्लॉट को नष्ट कर देंगे। हालांकि, ऊपर और दाएं (1) एक सुरक्षित कदम है।

यदि आप अपने बॉट को नाम देना चाहते हैं, तो name()विधि को ओवरराइड करें ।

बॉट्स प्रत्येक द्वंद्व के लिए फिर से बनाया जाएगा, इसलिए किसी भी स्थिर चर को रीसेट किया जाएगा।

शुभ लाभ!

आपके रॉकेट सच उड़ सकते हैं और आपके विरोधियों को धातु के स्क्रैपिंग के अलावा कुछ नहीं होना चाहिए।

संकेत:

विस्फोटकों को बनाने के लिए जानबूझकर रॉकेटों को विस्फोट करना विरोधियों के रॉकेटों को मार गिराने की तुलना में बचाव का एक आसान तरीका है।

उदाहरण बॉट

package bots;

import java.util.LinkedList;

import mechanics.*;




public class SimpleBot extends Bot {

    public String name(){
        return "Simple";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g){

        LinkedList<Integer> l = new LinkedList<Integer>();
        for(int i = 0; i < 12; i++){
            l.push(0);
        }
        return l;
    }

}

स्कोर

6-24 से स्कोर

Simple: 900
Zigzagoon: 3654
Wall-E: 3606
Tortoise: 2248
3 Shot: 2334
HatTrickBot: 4287
Sniper: 2973
SideShooter: 2491
Terminator: 4835
StraightShot: 3378
Defender: 4570
MoreDakka: 4324
king-of-the-hill  java 
— कैन
स्रोत
निश्चित क्रम से कोई फर्क नहीं पड़ता, अगर कोई बॉट RNG का उपयोग करता है तो मैं रनिंग को प्रति मैच 1000 बार बढ़ाऊंगा
— Cain
1
क्या यह जांचने का कोई तरीका है कि क्या प्रतिद्वंद्वी स्लॉट नष्ट हो गया है? getSlot (int) केवल हमारे स्लॉट्स के लिए है, है ना?
— काटनेंको
1
@ कैन यह दिलचस्प हो सकता है, किसी भी रॉकेट को नष्ट किए गए स्लॉट में लॉन्च करने में सक्षम न होने के लिए: 3
— कैटेन्को
1
@ मनु यह बग नहीं है, आप अपनी तरफ से बोर्ड को देख रहे हैं, इसलिए बाएं स्लॉट रिश्तेदार हैं
— काटनेंको
1
मुझे बहुत खेद है, उस बग को पहले ही तय कर लिया, मैं इसे धकेलना भूल गया!
— कैन

जवाबों:

3

रक्षक

डिफेंडर एक नए प्रकार के बचाव का उपयोग करता है: रॉकेट स्लॉट्स के सामने गश्त कर रहे हैं । यह एक बड़ा फायदा देता है, क्योंकि रॉकेट 5 मोड़ (विस्फोट की तरह) के बजाय 100 मोड़ के लिए रहते हैं।

package bots;

import java.util.LinkedList;
import mechanics.*;

public class Defender extends Bot {
    int turn = 0;

    @Override
    public String name() {
        return "Defender";
    }

    @Override
    public LinkedList<Integer> fireRocket(Rocket[][] grid) {
        LinkedList<Integer> command = new LinkedList<Integer>();
        for (int i = 0; i < 3; i++) {
            if ((grid[0][6+i] == null || grid[0][6+i].getDis().equals("v")) && (grid[1][6+i] == null || grid[1][6+i].getDis().equals("v")) && getSlot(i)) {
                curSlot = i;
                command.push(0);
                for (int j = 0; j < 50; j++) {
                    command.push(0);
                    command.push(4);
                }
                break;
            }
        }

        if (command.isEmpty()) {
            if ((grid[0][9] == null || grid[0][9].getDis().equals("v")) && (grid[0][10] == null || grid[0][10].getDis().equals("v")) && (grid[1][10] == null || grid[1][10].getDis().equals("v")) && getSlot(2)) {
                curSlot = 2;
                command.push(1);
                command.push(1);
                command.push(4);
                for (int i = 0; i < 50; i++) {
                    command.push(6);
                    command.push(2);
                }
            } else if ((grid[0][5] == null || grid[0][5].getDis().equals("v")) && (grid[0][4] == null || grid[0][4].getDis().equals("v")) && (grid[1][4] == null || grid[1][4].getDis().equals("v")) && getSlot(0)) {
                curSlot = 0;
                command.push(7);
                command.push(7);
                command.push(4);
                for (int i = 0; i < 50; i++) {
                    command.push(2);
                    command.push(6);
                }
            }

        }

        if (command.isEmpty()) {
            if (turn % 2 == 0 && getSlot(0)){
                curSlot = 0;
                command.push(7);
                command.push(7);
                for (int i = 0; i < 7; i++) {
                    command.push(0);
                }
                command.push(2);
                for (int i = 0; i < 2; i++) {
                    if (Math.random() < 0.2) command.push(2);
                }
                command.push(1);
            } else {
                curSlot = 2;
                command.push(1);
                command.push(1);
                for (int i = 0; i < 7; i++) {
                    command.push(0);
                }
                command.push(6);
                for (int i = 0; i < 2; i++) {
                    if (Math.random() < 0.5) command.push(6);
                }
                command.push(7);
            }
        }

        turn++;
        return command;
    }
}
— CommonGuy
स्रोत
वाह १। बहुत बढ़िया बॉट। लेकिन जैसा कि आप कहते हैं, बॉट दूसरी तरफ होने पर अच्छा खेलने में विफल रहता है।
— स्पिकैट्रिक्स
1
सुंदर निर्दोष खेल, बधाई
— Cain
6

Zigzagoon

बाहरी स्लॉट्स (थोड़े) चौड़े होते हैं, फिर आगे की ओर बढ़ते हैं और दुश्मन के स्लॉट की ओर वापस आते हैं। मध्य स्लॉट मध्य तक एक ज़िगज़ैग पैटर्न को गोली मारता है।

हर दूसरे दौर (3 मोड़), यह रक्षा मोड में चला जाता है और बस अपने खुद के स्लॉट के पास कुछ रॉकेटों को विस्फोट करता है। हमला मोड रॉकेट फिर उनके चारों ओर जाते हैं। कुछ भी नहीं फैंसी, बस कुछ पाने के लिए प्रतियोगिता और चल रहा है।

package bots;import java.util.*;import mechanics.*;

public class Zigzagoon extends Bot{
    String[] evenMoves = {"7000000001","0170710170","1000000007"};
    String[] oddMoves = {"0","00","0"};
    boolean even = true;
    public String name(){return "Zigzagoon";}

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        curSlot = (curSlot+1)%3;
        if(curSlot<1)even=!even;
        String[] moves = even?evenMoves:oddMoves;
        LinkedList<Integer> command = new LinkedList<Integer>();
        for(int i=0;i<moves[curSlot].length();i++)
            command.push(moves[curSlot].charAt(i)-'0');
        return command;
    }
}
— Geobits
स्रोत
निश्चित रूप से, अधिकांश अंतर से आया है, चाहे वह सही या गलत के रूप में शुरू हुआ हो। बॉट्स अब प्रत्येक मैच से पहले पुनर्निर्माण करते हैं।
— कैन
आह, यह समझ में आता है। मैं चर के बारे में भी नहीं सोचा था रीसेट नहीं। धन्यवाद :)
— जोबिट्स
5

टर्मिनेटर

मुझे टर्मिनेटर पेश करने पर गर्व है !!!

प्रत्येक रॉकेट बीच से काफी दूर / बाएं चलता है और दुश्मन के स्लॉट पर लौटता है। हर दो मोड़, एक रक्षा रॉकेट सीधे लॉन्च किया जाता है और इसे बचाने के लिए स्लॉट के पास विस्फोट होता है।

package bots;

import java.util.LinkedList;
import mechanics.Bot;
import mechanics.Rocket;

public class Terminator extends Bot {

    int n = 0;
    String[] moves = {"000", "0111107777", "00", "0077700111", "00", "0777701111"};

    public String name() {
        return "Terminator";
    }

    @Override
    public LinkedList<Integer> fireRocket(Rocket[][] g) {
        curSlot = (n+1) % 3;

        LinkedList<Integer> commands = loadCommands(moves[n % moves.length]);
        n++;

        return commands;
    }

    protected LinkedList<Integer> loadCommands(String commands) {
        LinkedList<Integer> linkedList = new LinkedList<Integer>();

        for (int i = 0; i < commands.length(); i++) {
            linkedList.push(commands.charAt(i) - 48);
        }

        return linkedList;
    }

}
— guy777
स्रोत
3

HatTrickBot

मैं CodeBot 3 के लिए DoubleTapBot था, जो एक मोड़ पर दो बार मार रहा था, यहाँ HatTrickBot आता है: एक ही समय में सभी 3 स्पॉट मारना!

एक रॉकेट को रोकने के लिए हमेशा हिट करना संभव है यदि आप जानते हैं कि यह कहां गिर जाएगा। लेकिन मुझे नहीं लगता कि कई रॉकेट हैं जो 3 रॉकेट हमले के खिलाफ अपने स्लॉट की रक्षा करने में सक्षम होंगे।

वैसे, हाँ, बार-बार स्विच के साथ इस तरह के अन्य को देखना भयानक है। मैं स्लॉट्स की स्थिति और टर्नऑंटर के प्रत्येक संयोजन के लिए अद्वितीय मूल्यों के साथ स्विच करने के लिए एक संस्करण बना सकता था। लेकिन इसे पढ़ना कठिन होगा (मुझे टिप्पणी में मूल्यों का अर्थ रखना होगा ... उबाऊ!) :)

package bots;
import java.util.LinkedList;
import mechanics.*;
/*
 * HatTrickBot always tries to destroy all the enemy slots at once
 * In order to achieve this, each slot needs extrem concentration and coordination
 * It explain why they need some turns to re-synchronized the rockets after one of them dies.
 */
public class HatTrickBot extends Bot
{
    // Default moves are at [0]
    // moves at [1] are used when there's only 2 slots remaining
    // moves  [2-4] are here for when there's only 1 slot remaining
    // it panicks, and can't establish how to fire to do a hat trick.
    // So he will just spamm every ennemy position, one at a time
    String[] rightSlot = {  "770002000020",
                            "0000000001",
                            "0000000000",
                            "0000000001",
                            "0000000011"};
    String[] midSlot   = {  "0000000000",
                            "11000060000",
                            "0000000000",
                            "0000000010",
                            "0000000700"};
    String[] leftSlot  = {  "11000060007",
                            "777702000020",
                            "0000000000",
                            "0000007000",
                            "0000077000"};
    int turnCounter=-1;
    public String name(){return "HatTrickBot";}
    public LinkedList<Integer> fireRocket(Rocket[][] g)
    {
        turnCounter=(turnCounter+1)%3;
        String[][] moves = {rightSlot,midSlot,leftSlot};
        LinkedList<Integer> ll = new LinkedList<Integer>();
        boolean slotL=getSlot(0),slotM=getSlot(1),slotR=getSlot(2);
        int movePoint=0;
        if(slotL&&slotM&&slotR)
        {
            switch(turnCounter)
            {
            case 0: curSlot=0;
                break;
            case 1: curSlot=2;
                break;
            case 2: curSlot=1;
                break;
                default:break;
            }
            movePoint=0;

        }
        else if(!slotM&&slotL&&slotR)
        {
            switch(turnCounter)
            {
            case 0: curSlot=0;
                    movePoint=0;
                break;
            case 1: curSlot=2;
                    movePoint=0;
                break;
            case 2: curSlot=0;
                    movePoint=1;
                break;
                default:break;
            }
        }
        else if(!slotL&&slotM&&slotR)
        {
            switch(turnCounter)
            {
            case 0: curSlot=0;
                    movePoint=0;
                break;
            case 1: curSlot=1;
                    movePoint=1;
                break;
            case 2: curSlot=0;
                    movePoint=1;
                break;
                default:break;
            }
        }
        else if(!slotR&&slotM&&slotL)
        {

            switch(turnCounter)
            {
            case 0: curSlot=2;
                    movePoint=1;
                break;
            case 1: curSlot=1;
                    movePoint=1;
                break;
            case 2: curSlot=1;
                    movePoint=0;
                break;
                default:break;
            }
        }
        else
        {
            if(slotR)curSlot=0;
            if(slotM)curSlot=1;
            if(slotL)curSlot=2;
            movePoint = 2+turnCounter;
        }
        for(int i=0;i<moves[curSlot][movePoint].length();i++)
            ll.push(Integer.parseInt(moves[curSlot][movePoint].charAt(i)+""));
        return ll;
    }
}
— Katenkyo
स्रोत
रॉकेट केवल हर दूसरे मोड़ को फायर करते हैं, इसलिए यह एक पूरी हैट ट्रिक हिट नहीं करता है। फिर भी बहुत प्रभावी है, हालांकि
— कैन
@ कैन हो, दुख की बात है कि यह हर 2 मोड़ है: /। फिर भी, मैं पहले राउंड का परिणाम देखूंगा, फिर एक असली हैट्रिक करने के लिए संशोधित करूंगा, अगर मुझे लगता है कि इसमें सुधार हो सकता है :)
— काटनेंको
रॉकेट को हर बार फायररकेट () कहा जाता है। तो अभी, वे एक दूसरे से एक मोड़ से अभी भी ऑफसेट हैं। आप मैच के एक दृश्य प्रतिनिधित्व को देखने के लिए नियंत्रक में परीक्षण फ़ाइल का उपयोग कर सकते हैं।
— कैन
@ मैं काम पर था जब मैंने उन बॉट्स को लिखा, तो मैंने उन्हें केवल स्पेक्स पर आधारित किया :)
— काटेनको
वाह, मैं प्रभावित हूँ आप यह लिखने में कामयाब रहे कि बिना किसी परीक्षण के, फिर बधाई। मैंने इसे और अधिक स्पष्ट करने के लिए चश्मे को अपडेट किया
— कैन
2

कछुआ

यदि मैं अपने सभी ठिकानों की रक्षा करता हूं, तो मेरे पास 3 अंक हैं। यदि ग्रिड अच्छी तरह से मिल जाए तो केवल 5 स्थानों से ही आक्रमण किया जा सकता है। रॉकेट 5 बारी मैदान पर ...

यह बॉट अपने लक्ष्य से मेल खाने के लिए इन सभी का उपयोग करता है: जेब में कम से कम 50% अंकों के साथ जीवित रहता है। यह 3 रॉकेट मारता है, फिर खुद को कवर करता है

package bots;

import java.util.LinkedList;

public class Tortoise extends Bot
{
    int turnCounter=-1;
    boolean attacked=false;
    int[] moves={7,0,0,0,1};
    public String name(){return "Tortoise";}
    public LinkedList<Integer> fireRocket(Rocket[][] g)
    {
         LinkedList<Integer> rocket = new LinkedList<Integer>();
         turnCounter++;
         if(!attacked)
         {
             curSlot=turnCounter;
             for(int i=0;i<11;i++)
                 rocket.push(0);
             if(turnCounter==2)
                 attacked=true;
             return rocket;
         }
         turnCounter%=5;
         switch(turnCounter)
         {
         case 0:
         case 1:curSlot=0;break;
         case 2:curSlot=1;break;
         case 3:
         case 4:curSlot=2;break;
            default:break;
         }
         rocket.push(moves[turnCounter]);
         return rocket;
    }
}
— Katenkyo
स्रोत
रॉकेट केवल हर दूसरे मोड़ पर आग लगाते हैं, इसलिए आप वास्तव में केवल ढाई दीवारों को बनाए रख सकते हैं
— कैन
@ कैन ओह, तो मैं इसे एक वास्तविक आश्रय के लिए संशोधित करूँगा :)
— कटेंकियो
2

SideShooter

पहले दो (अलग-अलग) बुर्ज के माध्यम से दो अलग-अलग तरीकों से शूट करता है। फिर, यह दो अलग-अलग तरीकों से अंतिम (सबसे बाएं) बुर्ज के माध्यम से गोली मारता है। फिर यह प्रत्येक बुर्ज के सामने रॉकेट से विस्फोट करके दूसरी (मध्य) बुर्ज के साथ एक "दीवार" बनाता है। इस प्रक्रिया को दोहराया जाता है।

यदि गेम 30 से अधिक मोड़ तक रहता है, तो साइडशूटर ऊब जाता है और एक छोटे तरीके से बदल जाता है। दूसरे (मध्य) बुर्ज के साथ एक "दीवार" बनाने के बजाय, यह सीधे गोली मारता है। बाकी के बुर्ज उसी तरह का व्यवहार करते हैं।

import java.util.LinkedList;

public class SideShooter extends Bot {

    int[] launcher = new int[]{1, 3, 2, 2, 2};
    String[] right = {"1100000077", "100000007"};
    String[] left  = {"7700000011", "700000001"}; 
    int position = -1;
    int turns = 0;

    public String name(){
        return "SideShooter";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g){
      LinkedList<Integer> directions = new LinkedList<Integer>();

      if(getSlot(0) || getSlot(1) || getSlot(2))      
          do{
              position = (position + 1) % 5;
              curSlot = launcher[position] - 1;
          }while(!getSlot(curSlot));

      if(position == 0)
      {
          String shoot = left[((int) (Math.random() * left.length))];
          for(int i=0; i < shoot.length(); i++)
              directions.push(shoot.charAt(i)-'0');
      }else if(position == 1)
      {
          String shoot = right[((int) (Math.random() * right.length))];
          for(int i=0; i < shoot.length(); i++)
              directions.push(shoot.charAt(i)-'0');
      }else
      {
          if(turns < 30)
          {
            if(position == 2 )
                directions.push(0);
            else if(position == 3)
                directions.push(1);
            else if(position == 4)
                directions.push(7);
          }else
              for(int i=0; i < 10; i++)
                  directions.push(0); 
      }
      turns ++;
      return directions;
    }

}
— Spikatrix
स्रोत
do...whileबयान अनंत लूप करना ...
— guy777
@ guy777, नहीं यह नहीं है। यह तब तक लूप करता है जब तक कि यह एक टूट-फूट बुर्ज न मिल जाए।
— स्पिकट्रिक्स
ठीक ! दो बार मैंने सभी बॉट्स, साइडशूटर और अन्य बॉट के साथ कोड लॉन्च किया (मुझे नहीं पता कि कौन सा) गेम खत्म नहीं कर सकता है !!!
— guy777
कुछ खेल अधूरा है। नियंत्रक की बारी सीमा होनी चाहिए।
— guy777
1
@CoolGuy मैंने उनके संपादन को अनुमोदित करने के लिए मतदान किया। स्वयं इसकी समीक्षा / परीक्षण अवश्य करें।
— mbomb007
2

निशानची

स्निपर पहले अपने दो पक्षों को अवरुद्ध करता है और फिर सीधे शूटिंग शुरू करता है।

import java.util.LinkedList;

public class Sniper extends Bot {

    int[] launcher = new int[]{1, 3, 1, 2, 3};
    String[] moves = {"7", "1", "0000000000", "0000000000", "0000000000"}; 
    int position = -1, move = 0;

    public String name(){
        return "Sniper";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        LinkedList<Integer> directions = new LinkedList<Integer>();

        if(getSlot(0) || getSlot(1) || getSlot(2))
        do{
            position = (position + 1) % launcher.length;
            curSlot = launcher[position] - 1;
        }while(!getSlot(curSlot));

        for(int i=0; i < moves[move].length(); i++)
            directions.push(moves[move].charAt(i)-'0');

        move = (move + 1) % moves.length;

        return directions;
    }

}
— Spikatrix
स्रोत
साइडशूटर पर टिप्पणियां देखें, यहां भी यही मुद्दा है।
— कैन
2

तीन शॉट

हमें कुछ अजीब शॉट्स उड़ते हुए मिले। कोई भी सच्चा बचाव नहीं है, लेकिन पैटर्न ऐसा है कि मिसाइलों के इस विचित्र ओले से एक शॉट प्राप्त करना कठिन होगा। (या यह विचार है। यह सबसे अधिक संभावना काम नहीं करेगा।)

package bots;import java.util.*;import mechanics.*;

public class ThreeShot extends Bot{
    public String name(){state = 0;return "3 Shot";}
    private int state;

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        LinkedList<Integer> command = new LinkedList<Integer>();
        if(state < 2){
           state++;
           return fireLeft();
        }
        if(state < 4){
           state++;
           return fireCenter();
        }
        state=(state+1)%6;
        return fireRight();
    }
    LinkedList<Integer> fireCenter(){
        LinkedList<Integer> command = new LinkedList<Integer>();
        curSlot = 1;
        while(command.size()<90){
            command.push(1);
            command.push(7);
            command.push(6);
            command.push(1);
        }
        return command;
    }
    LinkedList<Integer> fireRight(){
        LinkedList<Integer> command = new LinkedList<Integer>();
        curSlot = 2;
        command.push(1);
        for(int i=0;i<8;i++){
            command.push(0);
        }
        command.push(7);
        return command;
    }
    LinkedList<Integer> fireLeft(){
        LinkedList<Integer> command = new LinkedList<Integer>();
        curSlot = 0;
        command.push(7);
        for(int i=0;i<8;i++){
            command.push(6);
            command.push(1);
        }
        command.push(1);
        return command;
    }
}

ध्यान दें

— MegaTom
स्रोत
2

MoreDakka

मोरदक्का पांच दिशाओं में बिना रुके गोली मारता है (जब तक कि बुर्ज को अन्य मिसाइलों द्वारा नष्ट नहीं कर दिया जाता)।

import java.util.LinkedList;

public class MoreDakka extends Bot
{
    String[] moves={"70000000001", "0000000000", "0000000000", "0000000000", "1000000007"};
    int[] launcher = new int[]{0, 0, 1, 2, 2};
    int position = -1;

    public String name(){
        return "MoreDakka";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g)
    {
         LinkedList<Integer> directions = new LinkedList<Integer>();

         if(getSlot(0) || getSlot(1) || getSlot(2))
            do{
                position = (position + 1) % launcher.length;
                curSlot = launcher[position];
            }while(!getSlot(curSlot));

         for(int i=0; i < moves[position].length(); i++)
            directions.push(moves[position].charAt(i)-'0');

         return directions;
    }
}
— Spikatrix
स्रोत
1

StraightShot

जरा उन पर फायर करो।

package bots;import java.util.*;import mechanics.*;

public class StraightShot extends Bot{
    public String name(){return "StraightShot";}

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        LinkedList<Integer> command = new LinkedList<Integer>();
        curSlot = (curSlot+1)%3;
        for(int i=0;i<100;i++)
            command.push(0);
        return command;
    }
}
— MegaTom
स्रोत
1
यदि आप जागरूक नहीं थे, तो यह मूल रूप से वेवबॉट के समान है , नियंत्रक के साथ शामिल उदाहरण बॉट में से एक।
— जोबिट्स
@ जीबिट्स मुझे पता नहीं था कि उदाहरण बॉट मौजूद थे।
— मेगाटॉम
नमूना बॉट्स को नहीं देखने के लिए मेरा बुरा कहीं आसान है। मैं बस WaveBot को डिलीट करने वाला हूं और इस एंट्री को खड़ा करता हूं
— Cain
1

यहाँ मेरी अपनी प्रविष्टि है

walle

कुछ ऑफसेट रॉकेट को गोली मारता है, और उसके किनारों और केंद्र पर दीवारें बनाता है। 100 मोड़ के बाद, मध्य स्लॉट को लक्षित करना शुरू करता है।

package bots;

import java.util.LinkedList;
import java.util.Random;

import mechanics.*;


public class WallE extends Bot {

    int turn = 2;

    public String name(){
        return "Wall-E";
    }

    public LinkedList<Integer> fireRocket(Rocket[][] g){
        turn++;
        LinkedList<Integer> moves = new LinkedList<Integer>();
        curSlot = 1;
        switch(turn%4){
        case 0: 
            //Check the right wall
            if(getSlot(2)){
                curSlot = 2;
                moves.push(1);
                return moves;
            }
        case 1:
            //Check the left wall
            if(getSlot(0)){
                curSlot = 0;
                moves.push(7);
                return moves;
            }
        case 2:
            //Check the center wall
            if(getSlot(1)){
                curSlot = 1;
                moves.push(0);
                return moves;
            }
            break;
        default:
            //Fire a sneaky rocket
            Random rand = new Random();
            int direction = rand.nextInt(2);
            int back = 0;
            if(direction == 0 && getSlot(2)){ direction = 1; back = 7; curSlot = 2;}
            else{ direction = 7; back = 1; curSlot = 0; }
            moves.push(0);
            moves.push(direction);
            moves.push(direction);
            for(int i = 0; i < 5; i++){
                moves.push(0);
            }

            //Go for the center after turn 100
            if(turn > 104){
                moves.pop();
                moves.push(back);
            }
            moves.push(back);
            moves.push(back);


        }

        return moves;










    }

}
— कैन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.