রকেট বটস


11

রকেট বটস

বছরটি 3024 war মানুষ যুদ্ধে ঝুঁকিপূর্ণ হওয়ার পক্ষে খুব কম সংস্থান হয়ে উঠেছে, সুতরাং যুদ্ধটি রোবটগুলিতে স্থানান্তরিত হয়েছে। আপনার কাজটি অন্য কারও মতো বট তৈরি করা নয়, কে রকেটগুলি আপনার শত্রুদের উপর ধ্বংসের বৃষ্টিপাত করবে এবং আগত সমস্ত হুমকিকে ছুঁড়ে মারবে।

গেমপ্লের

বট

গেমপ্লে 10x15 গ্রিডে স্থান নেয়। আপনার বটটি নীচের প্রান্তে অবস্থিত এবং গ্রিডের 6,7 এবং 8 স্পটে তিনটি স্লট রয়েছে। আপনার বিপরীতে আপনার বিপরীতে তিনটি স্লট সহ গ্রিডের শীর্ষে অবস্থিত।

রকেটস

এই স্লটগুলির যে কোনও একটি থেকে আপনি রকেট গুলি চালাতে পারেন, ধরেই নেওয়া স্লটটি ধ্বংস হয়নি। রকেটটি তৈরি করার সময় প্রদত্ত দিকনির্দেশগুলির একটি তালিকা তৈরি করে এবং একবার চালিত হয়ে গেলে এই দিকনির্দেশগুলি পরিবর্তন করা যায় না। প্রতিটি পালা, রকেট তালিকার শীর্ষটি গ্রাস করবে এবং সেই দিকে চলে যাবে। রকেট একই সাথে চলাফেরা করে। দুটি রকেট যদি একই টাইলের শেষ হয় তবে সেগুলি উভয়ই বিস্ফোরিত হবে। কোনও রকেট যদি কমান্ডের বাইরে চলে যায় তবে এটি বিস্ফোরিত হবে। যদি কোনও রকেট জ্বালানীর বাইরে চলে যায়, 100 টি পদক্ষেপের পরে, এটি বিস্ফোরিত হবে। যখন কোনও রকেট বিস্ফোরিত হয়, তখন এটি 5 টর্কের জন্য সেই টাইলের মধ্যে থাকবে, অন্য কোনও রকেটগুলি সেখানে বিভক্ত হয়ে বিস্ফোরণ ঘটায়।

দ্রষ্টব্য: একই সাথে চলাফেরার কারণে, দুটি রকেট বিস্ফোরণ ছাড়াই একে অপরকে পাস করতে পারে, যতক্ষণ না তারা উভয়ই একই টাইলের একটি পালা শেষ না করে।

লক্ষ্য

প্রতিটি ম্যাচের লক্ষ্য হ'ল আপনার বাঁচিয়ে রাখার সময় আপনার প্রতিপক্ষের স্লটগুলি ধ্বংস করা। আপনার যে কোনও লাইভ স্লট থেকে রকেট নিক্ষেপ করা যেতে পারে, এবং গুলি চালানোর আগে আপনাকে মনোনীত একটি পথ দেওয়া হয়। আপনি প্রতি দ্বিতীয় ঘুরে একটি রকেট নিক্ষেপ করেন, এর অর্থ আপনি আরও একটি গুলি চালানোর আগে রকেট দু'বার সরে যাবে। একটি দ্বৈরথ 200 টির জন্য স্থায়ী হয় বা একটি বট স্লট সমস্ত ধ্বংস না হওয়া অবধি।

স্কোরিং

ম্যাচ শেষে, আপনার কাছে থাকা প্রতিটি লাইভ স্লটের জন্য আপনি একটি পয়েন্ট পাবেন এবং প্রতিটি প্রতিপক্ষের জন্য একটি পয়েন্ট আপনি ধ্বংস করেছেন। এর অর্থ এটি একটি শূন্য-সমষ্টি গেম এবং প্রতি ম্যাচটিতে points পয়েন্ট দেওয়া হবে।

একটি বৃত্তাকার রবিন চালানো হবে যাতে প্রতিটি বট একবার একে অপরের বটের মুখোমুখি হয়। যদি কোনও বটগুলি আরএনজি ব্যবহার করে তবে প্রতিটি ম্যাচআপ পরিবর্তে 1000 ডুয়েল হবে।

বাস্তবায়ন

প্রতিযোগিতার কোডটি এখানে পাওয়া যাবে: https://github.com/Cain93/ রকেটবটস

প্রতিটি জমা Botক্লাস প্রসারিত করা উচিত । আপনাকে অবশ্যই fireRocketপদ্ধতিটি ওভাররাইড করতে হবে । এই পদ্ধতিটি রকেটগুলির একটি গ্রিড অ্যারে গ্রহণ করে Rocket[][]যা গেমবোর্ডকে উপস্থাপন করে। আপনি সর্বদা স্থানে স্লট সঙ্গে, গ্রিড নীচে অবস্থিত হয় [-1][6], [-1][7], [-1][8]। গ্রিডে, অচেতন দাগগুলি প্রতিনিধিত্ব করা হবে null। যদি টাইলটিতে রকেট উপস্থিত থাকে তবে আপনি disক্ষেত্রটি অ্যাক্সেস করে সনাক্ত করতে পারবেন এটি কার সাথে সম্পর্কিত belongs "^" হ'ল আপনার রকেট, এবং "ভি" আপনার বিরোধী।

আপনাকে অবশ্যই একটি সংযুক্ত লিস্টলিস্ট ফিরিয়ে দিতে হবে যা আপনার রকেটের জন্য নির্দেশনা দেয়। উপরের দিকে যেতে, 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

স্থির তাই অর্ডারটি কিছু যায় আসে না, যদি কোনও বটগুলি আরএনজি ব্যবহার করে তবে আমি প্রতিযোগিতাটি প্রতি ম্যাচআপে 1000 গুণ বাড়িয়ে দেব
কেইন

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;
    }
}

বাহ +1। অসাধারণ বট তবে আপনি যেমনটি বলেছেন, বটটি অন্যদিকে থাকলে ভাল খেলতে ব্যর্থ হয়।
স্পিক্যাট্রিক্স

1
বেশ নির্লজ্জ ত্রুটিযুক্ত নাটক, অভিনন্দন
কেইন

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;
    }
}

স্থির, বেশিরভাগ পার্থক্য এসেছে যা থেকে এমনকি সত্য বা মিথ্যা হিসাবে শুরু হয়েছিল। প্রতিটি ম্যাচের আগে বটগুলি পুনর্নির্মাণ করুন।
কেইন

আহ, এটা বোঝা যায়। আমি ভেরিয়েবলগুলি পুনরায় সেট করার কথা ভাবিনি। ধন্যবাদ :)
জিওবিটস

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;
    }

}

3

HatTrickBot

আমার কাছে কোডবট 3 এর জন্য ডাবলট্যাপবট ছিল, যিনি একবার ঘুরে দু'বার আঘাত করছেন, এখানে হ্যাটট্রিকবট এসেছে: একই সাথে সমস্ত 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;
    }
}

রকেটগুলি কেবলমাত্র প্রতিটি অন্যান্য পালায় গুলি চালায় তাই এটি সম্পূর্ণ হ্যাট ট্রিককে হিট করে না। এখনও চূড়ান্ত কার্যকর যদিও
কেইন

@ কেইন হো, দু: খিত যে এটি প্রতি 2 বার পর: /। যাইহোক, আমি প্রথম রাউন্ডের ফলাফলটি দেখতে পাব তারপরে সত্যিকারের হ্যাটট্রিক করার জন্য এটি পরিবর্তন করুন যদি আমি মনে করি এটি এটি উন্নতি করতে পারে :)
কেটেনকিও

রকেটগুলি প্রতিবার ফায়ার রকেট () নামে ডাকা হয় between এখনই, তারা একে অপরের কাছ থেকে স্থির হয়ে দাঁড়িয়ে আছে। ম্যাচের ভিজ্যুয়াল উপস্থাপনা দেখতে আপনি নিয়ামকটিতে পরীক্ষা ফাইলটি ব্যবহার করতে পারেন।
কেইন

@ কেইন আমি যখন এই বটগুলি লিখেছিলাম তখন আমি কর্মে ছিলাম, তাই আমি কেবল তাদের
চশমার

বাহ, আমি মুগ্ধ হয়েছি আপনি লেখার জন্য পরিচালিত হয়েছিলেন কোনও পরীক্ষা ছাড়াই, বিন্যাস। এটিকে আরও স্পষ্ট করার জন্য আমি চশমাগুলি আপডেট করেছি
কেইন

2

কচ্ছপ

আমি যদি আমার সমস্ত ঘাঁটি রক্ষা করি তবে আমার 3 টি পয়েন্ট রয়েছে। গ্রিডটি ভালভাবে পেলে বেসগুলি কেবল 5 টি অবস্থান থেকে আক্রমণ করা যেতে পারে। রকেট মাঠে পাঁচটি পালা ...

এই বোটটি তার লক্ষ্যটি মেলানোর জন্য এই সমস্ত ব্যবহার করে: পকেটে অন্তত 50% পয়েন্ট নিয়ে বেঁচে থাকে। এটি 3 রকেট গুলি করে, তারপরে নিজেকে coverেকে রাখে

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;
    }
}

রকেটগুলি কেবল প্রতিটি অন্য দিকে আগুন জ্বালিয়ে দেয়, সুতরাং আপনি কেবল আড়াই দেওয়াল বজায় রাখতে পারবেন
কেইন

@ কেইন ওহ, সুতরাং আমি এটির একটি বাস্তব আশ্রয়স্থল হিসাবে পরিবর্তন করব :)
ক্যাটেনকিও

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;
    }

}

do...whileবিবৃতি অসীম লুপ না ...
guy777

@ লোক 7777, না তাই না। এটি ভেঙে যায় না যতক্ষণ না এটি একটি ভাঙ্গা ভাঁজ না পায়।
স্পিক্যাট্রিক্স

ঠিক আছে ! আমি প্রথম দুটি বার সমস্ত বট, সাইডশুটার এবং অন্যান্য বট দিয়ে কোডটি চালু করি (কোনটি আমি জানি না) গেমটি শেষ করতে পারে না !!!
777

কিছু গেম অপূর্ণযোগ্য। কন্ট্রোলারের একটি বাঁক সীমা থাকা উচিত।
777

1
কুলগুই আমি তার সম্পাদনাটি অনুমোদনের পক্ষে ভোট দিয়েছি। এটি নিজে পর্যালোচনা / পরীক্ষা করার বিষয়টি নিশ্চিত করুন।
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;
    }

}

সাইডশুটার, একই ইস্যুতে মন্তব্যগুলি এখানে দেখুন।
কেইন

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;
    }
}

বিঃদ্রঃ


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;
    }
}

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;
    }
}

1
যদি আপনি সচেতন না হন তবে এটি মূলত ওয়েভবোটের মতোই , নিয়ামকের সাথে অন্তর্ভুক্ত উদাহরণ বটগুলির মধ্যে একটি।
জিওবিটস

@ জিওবিটস আমার কাছে ধারণা ছিল না যে উদাহরণ বটসের অস্তিত্ব ছিল।
মেগাটম

স্যাম্পল বটগুলি আরও সহজে দেখার জন্য কোথাও না রাখার জন্য আমার খারাপ। আমি কেবল ওয়েভবট মুছে ফেলব এবং এই প্রবেশটি দাঁড়াতে দেব
কেইন

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;










    }

}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.