আপনার জীবনের সাথে আপনার ক্যান পাহারা!


10

খেলুন কিক দ্য ক্যান!

যদিও মুগি বর্তমান বিজয়ী, যদি কেউ তার মুকুট নিতে পারেন তবে তারা তা করতে উত্সাহিত হবে

ক্যান দ্য কিক একটি বাচ্চাদের খেলা। একজন ডিফেন্ডার এবং একাধিক আক্রমণকারী জড়িত। আজ আর এমন খেলা আর নেই! আপনার কাজটি হ'ল একটি বট লিখুন যা এটি খেলবে, জয়ের জন্য, !

https://en.wikipedia.org/wiki/Kick_the_can

এই গেমটিতে কিছু মূল পার্থক্য রয়েছে। প্রথম মূল পার্থক্যটি হ'ল গেমটি মাল্টিপ্লেয়ার (5v5)। দ্বিতীয় মূল পার্থক্য হ'ল উভয় সেট বট উভয় খনি এবং নিক্ষেপ করা বোমা দিয়ে শত্রু খেলোয়াড়কে হত্যা করতে এবং নির্মূল করতে পারে! বটগুলি পাঁচটি বেশি ব্লকের দূরে কোনও খনি (দূরত্ব নির্বিশেষে) বা খেলোয়াড় দেখতে পাবে না!

ম্যাপটি নীচে একটি গোলকধাঁধা।

ধাঁধা

এই গোলকধাঁটি প্রক্রিয়াগতভাবে একটি গভীরতা প্রথম পুনরাবৃত্ত ব্যাকট্রাকিং অ্যালগরিদম ব্যবহার করে একটি ধাঁধা তৈরির মাধ্যমে তৈরি করা হয়। এবং তারপরে দেখানো গর্তগুলিতে স্থাপন করুন (পাশাপাশি গোলকধাঁটিকে আরও "অপূর্ণ" করুন The গোলকধাঁধাটি 65x65 ব্লক প্রশস্ত এবং শূন্য সূচীযুক্ত Thus সুতরাং নীল পতাকাটি (ক্যান) 1,1 এবং লাল পতাকাটি (ক্যান) হয় Blue৩,63৩ এ। নীল দলটি ২,২ এবং ৩,৩,৪,৪ এ প্রসারিত হয়েছে। লাল দল ,২,62২ এবং ,১,61১, 60০,60০ ইত্যাদি স্প্যান করেছে। সায়ানের ব্লকগুলি নীল দলের উপরের বট এবং ম্যাজেন্টায় ব্লকগুলি লাল বট হয় গেমটি সর্বদা পাঁচটি বনাম পাঁচটি হয় the দলের প্রতিটি বট আপনার কোড ব্যবহার করবে (তবে অন্যান্য উদাহরণের ভেরিয়েবলগুলি সংরক্ষণ করতে পারে (বা স্থানীয় ফাইলগুলি তৈরি করতে পারে) রাষ্ট্রের ট্র্যাক রাখতে এবং ভূমিকা পৃথক করতে পারে।


গেমপ্লের

আপনি ধূসর দেখতে পারেন হিসাবে খনি স্থাপন করা যেতে পারে। এবং বোমা সর্বোচ্চ চারটি ব্লকের দূরত্বে নিক্ষেপ করা যেতে পারে। এই দেয়াল এবং অন্যান্য খেলোয়াড়দের মাধ্যমে চারটি ব্লক অবধি কেবল আপনার শত্রুদের হত্যা করে enemies প্রতিটি পদক্ষেপের পরে তাদের 40% হয়ে যাওয়ার সম্ভাবনা রয়েছে। সুতরাং তাদের কাছে 1 রেঞ্জের 100% সম্ভাবনা রয়েছে 2% এর 3 টি পরিসরে 36% এবং তিনটি পরিসরে 21.6% একটি খনি স্থাপন বা বোমা নিক্ষেপ করতে একটি দল গোলাগুলি লাগে। এটি 0 থেকে শুরু হয় এবং কমলার বাক্সগুলি সংগ্রহ করে বাড়ানো যায়। মনে রাখবেন যে এই চারটি (4) গোলাগুলি সহজেই কেন্দ্রিক হবে। বটগুলি দুটি লাল এবং দুটি নীল রঙের একটি অ্যারে রেখাযুক্ত থাকে। আইআরআরআরআরআরবিবিবিবিবি। পতাকা গৌড়িংয়ের অনুমতি রয়েছে তবে সতর্ক থাকুন যে পতাকার কাছে থাকা (অর্থাত্ পাঁচটি ব্লকের চেয়ে কম) ফলস্বরূপ হ্রাস পায় এবং কেবল চলন্তকে অনুমতি দেয়। প্রতি তিনটি মোড়। অ্যারেনা প্রতিটি টার্নের জন্য একটি এলোমেলো স্টার্টার বাছাই করে। আই

উদ্দেশ্য

ভুলক্রমে চলাচল সফলভাবে নেভিগেট করতে এবং বিপরীত ক্যানটিকে স্পর্শ করতে গিয়ে নিজের ক্যানটিকে দুর্ঘটনাক্রমে আঘাত না করার জন্য বা খনিতে পদক্ষেপ নেওয়ার জন্য আপনার পাঁচটি বট (প্রত্যেকটির একই শ্রেণীর ফাইল রয়েছে) প্রোগ্রাম করুন।

প্রোগ্রামিং

আখড়া এবং বট এন্ট্রিগুলি বর্তমানে জাভাতে রয়েছে তবে অন্যান্য ভাষার জন্য স্টিডিন / আউট র্যাপার বিদ্যমান।

আঞ্চলিক কোডটি উপলব্ধ করা হবে তবে এখানে সম্পর্কিত বিবরণ।

বট ক্লাস

public class YourUniqueBotName extends Bot{
public YourUniqueBotName(int x , int y, int team){
super(x,y,team);
//optional code
}
public Move move(){//todo implement this method 
//it should output  a Move();
//A move has two paramaters
//direction is from 0 - 3 as such
//         3
//       2-I-0
//         1
// a direction of 4 or higher means a no-op (i.e stay still)
//And a MoveType. This movetype can be    
//MoveType.Throw
//MoveType.Mine
//MoveType.Defuse defuse any mine present in the direction given
//MoveType.Move
}
}

মূল পদ্ধতি উপলব্ধ

নোট করুন যে ডেটা সংশোধন করতে বা অ্যাক্সেস করার জন্য কোনও কৌশল ব্যবহার করার ক্ষেত্রে আপনার সাধারণত অ্যাক্সেস থাকা উচিত নয় এবং এর ফলে অযোগ্যতার ফলস্বরূপ।

Arena.getAmmo()[team];//returns the shared ammo cache of your team

Arena.getMap();//returns an integer[] representing the map. Be careful since all enemies more than 5 blocks away (straight line distance) and all mines are replaced with constant for spaces
//constants for each block type are provided such as Bot.space Bot.wall Bot.mine Bot.redTeam Bot.blueTeam Bot.redFlag Bot.blueFlag

Arena.getAliveBots();//returns the number of bots left

getX();//returns a zero indexed x coordinate you may directly look at (but not change X)

getY();//returns a zero indexed y coordinate (y would work to, but do not change y's value)

//Although some state variables are public please do not cheat by accessing modifying these

স্ট্যান্ডিন / আউট র‌্যাপার ইন্টারফেস স্পেসিফিকেশন

ইন্টারফেসটি দুটি মোড নিয়ে গঠিত: আরম্ভ এবং চলমান।

ইনিশিয়েশন মোড চলাকালীন স্ট্যান্ডআউটের মাধ্যমে একটি একক আইএনআইটি ফ্রেম প্রেরণ করা হয়। এই ফ্রেমের স্পেসিফিকেশনটি নিম্নরূপ:

INIT
{Team Membership Id}
{Game Map}
TINI

যেখানে: {টিম সদস্যপদ আইডি an একটি একক চরিত্র: আর বা বি বি অর্থ নীল দল, আর এর অর্থ লাল দল।

{গেম ম্যাপ} হ'ল মানচিত্রের এক সারি উপস্থাপন করে এমন একাধিক অক্ষরের সারি সিরিজ। নিম্নলিখিত আসকি অক্ষরগুলি বৈধ: এফ = নীল পতাকা জি = লাল পতাকা ও = উন্মুক্ত স্থান ডাব্লু = প্রাচীর

গেমটি তারপরে প্রতিটি বটকে স্টাডাউটের উপর দিয়ে গেমের ফ্রেমগুলি প্রেরণ করতে এগিয়ে যাবে:

FRAME
{Ammo}
{Alive Bot Count}
{Bot X},{Bot Y}
{Local Map}
EMARF

কোথায়:

Mo অ্যাম্মো digit হল অঙ্কের একটি স্ট্রিং, মান 0 বা ততোধিক হবে {অ্যালাইভ বট কাউন্ট Count অঙ্কের একটি স্ট্রিং, মান 0 বা ততোধিক হবে {বক্স এক্স} হ'ল বটের এক্স কো-অর্ডিনেটের প্রতিনিধিত্ব করে এমন সংখ্যার একটি স্ট্রিং খেলা মানচিত্রে। মান 0 <= এক্স <মানচিত্রের প্রস্থ হবে। {বক্স ওয়াই হ'ল অঙ্কের একটি স্ট্রিং যা গেমের মানচিত্রে বটের Y- সমন্বয়কে উপস্থাপন করে। মান 0 <= Y <মানচিত্রের উচ্চতা হবে। {স্থানীয় মানচিত্র বোটের চারপাশে পুরো মানচিত্রের প্রতিনিধিত্ব করে এমন একাধিক সারি সারি অক্ষরগুলির ক্রম। নিম্নলিখিত আসকি অক্ষরগুলি বৈধ: এফ = নীল পতাকা জি = লাল পতাকা ও = উন্মুক্ত স্থান ডাব্লু = প্রাচীর আর = লাল দল বট বি = নীল দলের বট এম = মাইন এ = গোলাগুলি

কন্ট্রোলারটি আশা করে যে আপনার বট ফর্ম্যাটটিতে একক রেখার প্রতিক্রিয়া আউটপুট করবে (স্টাটআউটে):

{Action},{Direction}

কোথায়:

{অ্যাকশন of এর মধ্যে একটি: মুভ ডিফলিজ মাইন থ্রো

{দিকনির্দেশ 0 এবং 4 সমেত একক অঙ্ক। (দিকনির্দেশের তথ্য আগে দেখুন)

দ্রষ্টব্য: সমস্ত স্ট্রিং Line n লাইন অক্ষরের শেষে দিয়ে সীমিত করা হবে।

এটি একটি এলিমিনেশন টুর্নামেন্ট হবে। আমার নমুনা বট ফিলার হিসাবে অংশ নেবে, কিন্তু আমি নিজেকে বিজয়ী করব না। আমার কোনও বটের দ্বারা জয়লাভের ক্ষেত্রে শিরোনামটি দ্বিতীয় স্থানের সদস্যের কাছে যায় এবং এমন একটি বট না পাওয়া পর্যন্ত অব্যাহত থাকবে যা আমার কোনও নয়। প্রতিটি ম্যাচে 11 রাউন্ড কিক ক্যান থাকে। ততক্ষণে কোনও দলই যদি একটি ম্যাচ জিততে না পারে তবে তারা দুজনই বাদ পড়ে। শূন্য নম্বরের স্কোর থাকলে টাই টাই ব্রেকার ম্যাচ খেলবে। টাই থাকলে উভয়ই বাদ পড়ে যায়। পরবর্তী রাউন্ডে আরও বেশি মিল থাকতে পারে। টুর্নামেন্টের সিডিং 7/31/16 (পরিবর্তনের সাধ্যের তারিখ) হিসাবে প্রাপ্ত সংখ্যার উপর ভিত্তি করে তৈরি হবে।

প্রতিটি ম্যাচ 4096 টার্নে চলে। একটি বিজয় একটি পয়েন্ট দেয়। একটি টাই বা ক্ষতি শূন্য পয়েন্ট মঞ্জুরি দেয়। শুভকামনা!

কোডটি দেখার জন্য নির্দ্বিধায় বা এই গিটহাব রেপোতে এটির সমালোচনা করুন।

https://github.com/rjhunjhunwala/BotCTF/blob/master/src/botctf/Arena.java


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

  • যুক্তিসঙ্গত পরিমাণে প্রতিক্রিয়া জানুন (250 এমএস বলুন)
  • আমার হোস্ট মেশিনের ক্ষতি করবে না

@ মুগি আমি এটি প্রকাশের সিদ্ধান্ত নিয়েছি
রোহান ঝুনঝুনওয়ালা

স্থানীয় মানচিত্রে, এটি বটগুলির দৃষ্টির বাইরে টাইলগুলির জন্য কী দেখায়?
জাস্টহেল্ফ

এটি মানচিত্র দেখায়। কেবলমাত্র এটি হ'ল আপনি বটগুলি আরও বেশি দূরত্বে দেখতে পাচ্ছেন না। আপনার বটগুলি আখড়ার একটি আসল মানচিত্র সরবরাহ করা হয়েছে তবে তারা সেখানে না পারে যেখানে চৌকস বিরোধীরা লুকিয়ে রয়েছে। @ আসফালফ
রোহান ঝুনঝুনওয়ালা

@ মুগি, আমি ভাবছিলাম যে আপনি যদি আমার জন্য অজগর বট লিখতে পারেন তবে আমি স্টিডিন / স্টাডাউট র‍্যাপারটি পরীক্ষা করতে পারি
রোহান ঝুনঝুনওয়ালা

সুতরাং বটস দৃষ্টিভঙ্গির বাইরে থাকা মানচিত্রটি খালি জায়গা হিসাবে ঠিক দেখাবে, তাই না?
জাস্টহেল্ফ

উত্তর:


4

নাভপয়েন্টবট, জাভা 8

এখানে চিত্র বর্ণনা লিখুন বট সাদা / নীল

এই বটটি প্রতিটি ফ্রেমকে বন্ধুত্বপূর্ণ বট থেকে একজন নেতার মনোনীত করে যা তারপরে প্রতিটি বোটে নেভিগেট করার জন্য নেভ পয়েন্ট নির্ধারণ করে।

মূলত, সমস্ত বটগুলি গোলাবারুদ ডিপোতে সন্ধানের দায়িত্বে থাকে, তারপরে দুটি বটকে রক্ষী হিসাবে নিযুক্ত করা হয় বাকি গুলোতে গোলাবারুদ সন্ধান করে এবং তারপরে শত্রু পতাকায় আক্রমণ করে।

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

সাথে চালাও java NavPointBot

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

public final class NavPointBot implements Serializable 
{
    private static final int[][] offsets = new int[][]{{-1,0},{0,-1},{1,0},{0,1}};
    private static final List<int[]> navPointsBlue = Arrays.asList(new int[][]{{1,2},{2,1}});
    private static final List<int[]> navPointsRed = Arrays.asList(new int[][]{{63,62},{62,63}});
    transient private static int mapWidth=0;
    transient private static int mapHeight=0;
    transient private char[][] map;
    transient private char team;
    transient private int ammo;
    transient private int botsAlive;
    transient private int enemyFlagX;
    transient private int enemyFlagY;
    private int frameCount;
    private int botX;
    private int botY;
    private String id;
    private int navPointX;
    private int navPointY;

    transient static Object synchObject = new Object(); // used for file read/write synchronisation if multiple instances are run in the same VM

    final static class Data implements Serializable
    {
        int frameCount;
        boolean[][] diffusedMap = new boolean[mapWidth][mapHeight];
        Map<String,NavPointBot> teamMembers = new HashMap<>();
    }

    interface DistanceWeigher
    {
        double applyWeight(NavPointBot p1Bot, PathSegment p1);
    }

    static class PathSegment
    {
        public PathSegment(int tileX, int tileY, int fscore, int gscore, PathSegment parent, int direction, int targetX, int targetY)
        {
            super();
            this.tileX = tileX;
            this.tileY = tileY;
            this.fscore = fscore;
            this.gscore = gscore;
            this.parent = parent;
            this.direction = direction;
            this.targetX = targetX;
            this.targetY = targetY;
        }
        public PathSegment(PathSegment parent)
        {
            this.parent = parent;
            this.targetX = parent.targetX;
            this.targetY = parent.targetY;
        }
        int tileX;
        int tileY;
        int fscore;
        int gscore;
        int direction;
        PathSegment parent; 
        int targetX;
        int targetY;
    }

    public static void main(String[] args) throws Exception
    {
        new NavPointBot(UUID.randomUUID().toString());
    }

    private NavPointBot(String id) throws Exception
    {
        this.id = id;
        System.err.println("NavPointBot ("+id+") STARTED");

        Data data;
        while(true)
        {
            String line=readLine(System.in);

            // decode initial frame
            if ("INIT".equals(line))
            {
                // read team membership
                team = readLine(System.in).charAt(0);

                // get the map
                line = readLine(System.in);

                List<char[]> mapLines = new ArrayList<>();
                while(!"TINI".equals(line))
                {
                    mapLines.add(line.toCharArray());
                    line = readLine(System.in);
                }
                map = mapLines.toArray(new char[][]{});
                mapHeight = map.length;
                mapWidth = map[0].length;

                out:
                for (int y = 0; y<mapHeight;y++)
                {
                    for (int x=0; x<mapWidth;x++)
                    {
                        if (map[y][x]==(team=='B'?'G':'F'))
                        {
                            enemyFlagX = x;
                            enemyFlagY = y;
                            break out;
                        }
                    }
                }
                data = readSharedData();
                data.diffusedMap=new boolean[mapWidth][mapHeight];
                writeSharedData(data);

            }
            else
            {
                System.err.println("Unknown command received: "+line);
                return;
            }

            line = readLine(System.in);
            while (true)
            {
                // decode frame
                if ("FRAME".equals(line))
                {
                    frameCount = Integer.parseInt(readLine(System.in));
                    ammo = Integer.parseInt(readLine(System.in));
                    botsAlive = Integer.parseInt(readLine(System.in));
                    line = readLine(System.in);
                    String[] splits = line.split(",");
                    botX = Integer.parseInt(splits[0]);
                    botY = Integer.parseInt(splits[1]);

                    // get the map
                    line = readLine(System.in);

                    int row=0;
                    while(!"EMARF".equals(line))
                    {
                        map[row++] = line.toCharArray();
                        line = readLine(System.in);
                    }
                }
                else
                {
                    System.err.println("Unknown command received: "+line);
                    return;
                }


                data = readSharedData();

                // this bot is nomitated to be the leader for this frame
                if (data.frameCount<frameCount || (frameCount==0 && data.frameCount > 3))
                {
                    data.frameCount=frameCount;

                    List<NavPointBot> unassignedBots = new ArrayList<>(data.teamMembers.values());

                    // default nav points to be enemy flag location.
                    unassignedBots.forEach(t->{t.navPointY=enemyFlagY;t.navPointX=enemyFlagX;});

                    // after 700 frames assume dead lock so just storm the flag, otherwise...
                    if (frameCount<700)
                    {
                        // if the after the initial rush then we will assign guard(s) while we have enemies
                        if (frameCount>70 && botsAlive > data.teamMembers.size())
                        {
                            Map<NavPointBot, PathSegment> navPointDistances = assignBotShortestPaths(unassignedBots,team=='B'?navPointsBlue:navPointsRed,true, new DistanceWeigher() {

                                @Override
                                public double applyWeight( NavPointBot owner ,PathSegment target) {
                                    return target.gscore;
                                }
                            });
                            navPointDistances.keySet().forEach(s->{s.navPointX=navPointDistances.get(s).targetX;s.navPointY=navPointDistances.get(s).targetY;});
                        }


                        // the remaining bots will go to ammo depots with a preference to the middle ammo depots
                        List<int[]> ammoDepots = new ArrayList<>();
                        for (int y = 0; y<mapHeight;y++)
                        {
                            for (int x=0; x<mapWidth;x++)
                            {
                                if (map[y][x]=='A')
                                {
                                    ammoDepots.add(new int[]{x,y});
                                }
                            }
                        }

                        System.err.println("ammoDepots: "+ammoDepots.size());
                        if (ammoDepots.size()>0)
                        {
                            Map<NavPointBot, PathSegment> ammoDistances = assignBotShortestPaths(unassignedBots,ammoDepots,true, new DistanceWeigher() {

                                @Override
                                public double applyWeight( NavPointBot owner ,PathSegment target) {
                                    return target.gscore + (Math.abs(target.targetX-mapWidth/2)+Math.abs(target.targetY-mapHeight/2)*10);
                                }
                            });


                            // assign ammo depot nav points to closest bots
                            ammoDistances.keySet().forEach(s->{s.navPointX=ammoDistances.get(s).targetX;s.navPointY=ammoDistances.get(s).targetY;});
                        }
                    }

                    System.err.println("FRAME: "+frameCount+" SET");
                    data.teamMembers.values().forEach(bot->System.err.println(bot.id+" nav point ("+bot.navPointX+","+bot.navPointY+")"));
                    System.err.println();
                }


                // check to see if enemies are in range, if so attack the closest
                List<int[]> enemies = new ArrayList<>();
                for (int y = 0; y<mapHeight;y++)
                {
                    for (int x=0; x<mapWidth;x++)
                    {
                        if (map[y][x]==(team=='B'?'R':'B'))
                        {
                            int attackDir = -1;
                            int distance = -1;
                            if (x==botX && Math.abs(y-botY) < 4) { distance =  Math.abs(y-botY); attackDir = botY-y<0?1:3;}
                            if (y==botY && Math.abs(x-botX) < 4) { distance =  Math.abs(x-botX); attackDir = botX-x<0?0:2;}
                            if (attackDir>-1)
                            {
                                enemies.add(new int[]{x,y,distance,attackDir});
                            }
                        }
                    }
                }

                enemies.sort(new Comparator<int[]>() {

                    @Override
                    public int compare(int[] arg0, int[] arg1) {
                        return arg0[2]-arg1[2];
                    }
                });

                String action;

                // attack enemy if one within range...
                if (enemies.size()>0)
                {
                    action = "Throw,"+enemies.get(0)[3];
                }
                else
                {
                    // set action to move to navpoint
                    PathSegment pathSegment = pathFind(botX,botY,navPointX,navPointY,map,true);
                    action = "Move,"+pathSegment.direction;

                    // clear mines if within 5 spaces of enemy flag

                    if ((team=='B' && botX>=mapWidth-5 && botY>=mapHeight-5 ) ||
                        (team=='R' && botX<5 && botY<5 ))
                    {
                        if (!data.diffusedMap[pathSegment.parent.tileX][pathSegment.parent.tileY])
                        {
                            action = "Defuse,"+pathSegment.direction;
                            data.diffusedMap[pathSegment.parent.tileX][pathSegment.parent.tileY]=true;
                        }
                    }

                }

                writeSharedData(data);
                System.out.println(action);
                line = readLine(System.in);
            }
        }
    }

    /**
     * assigns bots to paths to the given points based on distance to the points with weights adjusted by the given weigher implementation 
     */
    private Map<NavPointBot, PathSegment> assignBotShortestPaths(List<NavPointBot> bots, List<int[]> points, boolean exact, DistanceWeigher weigher) {

        Map<Integer,List<PathSegment>> pathMap = new HashMap<>();
        final Map<PathSegment,NavPointBot> pathOwnerMap = new HashMap<>();

        for (NavPointBot bot : bots)
        {
            for(int[] navPoint: points)
            {
                List<PathSegment> navPointPaths = pathMap.get((navPoint[0]<<8)+navPoint[1]);
                if (navPointPaths == null)
                {
                    navPointPaths = new ArrayList<>();
                    pathMap.put((navPoint[0]<<8)+navPoint[1],navPointPaths);
                }
                PathSegment path = pathFind(bot.botX,bot.botY,navPoint[0],navPoint[1],map,exact);
                pathOwnerMap.put(path, bot);
                navPointPaths.add(path);
            }
        }


        // assign bot nav point based on shortest distance
        Map<NavPointBot, PathSegment> results = new HashMap<>();
        for (int[] navPoint: points )
        {
            List<PathSegment> navPointPaths = pathMap.get((navPoint[0]<<8)+navPoint[1]);

            if (navPointPaths !=null)
            {
                Collections.sort(navPointPaths, new Comparator<PathSegment>() {

                    @Override
                    public int compare(PathSegment p1, PathSegment p2) {

                        NavPointBot p1Bot = pathOwnerMap.get(p1);
                        NavPointBot p2Bot = pathOwnerMap.get(p2);
                        double val = weigher.applyWeight(p1Bot, p1) - weigher.applyWeight(p2Bot, p2);
                        if (val == 0)
                        {

                            return p1Bot.id.compareTo(p2Bot.id);
                        }
                        return val<0?-1:1;
                    }
                });

                for (PathSegment shortestPath : navPointPaths)
                {
                    NavPointBot bot = pathOwnerMap.get(shortestPath);

                    if (!results.containsKey(bot) )
                    {
                        results.put(bot,shortestPath);
                        bots.remove(bot);
                        break;
                    }
                }
            }
        }
        return results;
    }

    /**
     * reads in the previous bot's view of teammates aka shared data
     */
    private Data readSharedData() throws Exception
    {
        synchronized(synchObject)
        {
            File dataFile = new File(this.getClass().getName()+"_"+team);

            Data data;
            if (dataFile.exists())
            {
                FileInputStream in = new FileInputStream(dataFile);
                try {
                    java.nio.channels.FileLock lock = in.getChannel().lock(0L, Long.MAX_VALUE, true);
                    try {
                        ObjectInputStream ois = new ObjectInputStream(in);
                        data = (Data) ois.readObject();
                    } catch(Exception e)
                    {
                        System.err.println(id+": CORRUPT shared Data... re-initialising");
                        data = new Data();
                    }
                    finally {
                        lock.release();
                    }
                } finally {
                    in.close();
                }
            }
            else
            {
                System.err.println(id+": No shared shared Data exists... initialising");
                data = new Data();
            }

            //purge any dead teammates...
            for (NavPointBot bot : new ArrayList<>(data.teamMembers.values()))
            {
                if (bot.frameCount < frameCount-3 || bot.frameCount > frameCount+3)
                {
                    data.teamMembers.remove(bot.id);
                }
            }

            // update our local goals to reflect those in the shared data
            NavPointBot dataBot = data.teamMembers.get(id);
            if (dataBot !=null)
            {
                this.navPointX=dataBot.navPointX;
                this.navPointY=dataBot.navPointY;
            }

            // ensure that we are a team member
            data.teamMembers.put(id, this);

            return data;
        }
    }

    private void writeSharedData(Data data) throws Exception
    {
        synchronized(synchObject)
        {
            File dataFile = new File(this.getClass().getName()+"_"+team);
            FileOutputStream out = new FileOutputStream(dataFile);

            try {
                java.nio.channels.FileLock lock = out.getChannel().lock(0L, Long.MAX_VALUE, false);
                try {
                    ObjectOutputStream oos = new ObjectOutputStream(out);
                    oos.writeObject(data);
                    oos.flush();
                } finally {
                    lock.release();
                }
            } finally {
                out.close();
            }
        }
    }

    /**
     * return the direction to move to travel for the shortest route to the desired target location
     */
    private PathSegment pathFind(int startX, int startY, int targetX,int targetY,char[][] map,boolean exact)
    {
        // A*
        if (startX==targetX && startY==targetY)
        {
            return new PathSegment(targetX,targetY,0, 0,null,4,targetX,targetY);//PathSegment.DEFAULT;
        }
        else
        {
            int[][] tileIsClosed = new int[mapWidth][mapHeight];

            // find an open space in the general vicinity if exact match not required
            if (!exact)
            {
                out:
                for (int y=-1;y<=1;y++)
                {
                    for (int x=-1;x<=1;x++)
                    {
                        if (startX == targetX+x && startY==targetY+y)
                        {
                            return new PathSegment(targetX,targetY,0, 0,null,4,targetX,targetY);//PathSegment.DEFAULT;
                        }
                        else if (targetY+y>=0 && targetY+y<mapHeight && targetX+x>=0 && targetX+x < mapWidth && map[targetY+y][targetX+x]=='O')
                        {
                            targetX+=x;
                            targetY+=y;
                            break out;
                        }
                    }
                }
            }

            PathSegment curSegment = new PathSegment(targetX,targetY,1,1,null,4,targetX,targetY);
            PathSegment newSegment;
            Set<PathSegment> openList = new HashSet<PathSegment>();
            openList.add(curSegment);

            do
            {
                if (openList.isEmpty())
                {
                    break;
                }
              PathSegment currentBestScoringSegment = openList.iterator().next();
              //  Look for the lowest F cost square on the open list
              for (PathSegment segment : openList)
              {
                if (segment.fscore<currentBestScoringSegment.fscore)
                {
                  currentBestScoringSegment = segment;
                }
              }
              curSegment = currentBestScoringSegment;

              // found path
              if (startX==curSegment.tileX && startY==curSegment.tileY)
              {
                break;
              }

              // if not in closed list
              if (tileIsClosed[curSegment.tileX][curSegment.tileY]==0)
              {
                    // Switch it to the closed list.
                    tileIsClosed[curSegment.tileX][curSegment.tileY]=1;
                    // remove from openlist
                    openList.remove(curSegment);


                    // add neigbours to the open list if necessary
                    for (int i=0;i<4;i++)
                    {

                        int surroundingCurrentTileX=curSegment.tileX+offsets[i][0];
                        int surroundingCurrentTileY=curSegment.tileY+offsets[i][1];
                        if (surroundingCurrentTileX>=0 && surroundingCurrentTileX<mapWidth &&
                            surroundingCurrentTileY>=0 && surroundingCurrentTileY<mapHeight )
                        {
                            newSegment = new PathSegment( curSegment);
                            newSegment.tileX = surroundingCurrentTileX;
                            newSegment.tileY = surroundingCurrentTileY;
                            newSegment.direction = i;

                            switch(map[surroundingCurrentTileY][surroundingCurrentTileX])
                            {
                                case 'W':
                                case 'F':
                                case 'G':
                                    continue;
                            }

                          int surroundingCurrentGscore=curSegment.gscore+1 + ((surroundingCurrentTileX!=startX && surroundingCurrentTileY!=startY && map[surroundingCurrentTileY][surroundingCurrentTileX]==team)?20:0);//+map[surroundingCurrentTileY][surroundingCurrentTileX]!='O'?100:0;
                          newSegment.gscore=surroundingCurrentGscore;
                          newSegment.fscore=surroundingCurrentGscore+Math.abs( surroundingCurrentTileX-startX)+Math.abs( surroundingCurrentTileY-startY);
                          openList.add(newSegment);
                        }
                    }
              }
              else
              {
                  // remove from openlist
                  openList.remove(curSegment);    
              }
            } while(true);

            return curSegment;
        }
     }

    /**
     * Reads a line of text from the input stream. Blocks until a new line character is read.
     * NOTE: This method should be used in favor of BufferedReader.readLine(...) as BufferedReader buffers data before performing
     * text line tokenization. This means that BufferedReader.readLine() will block until many game frames have been received. 
     * @param in a InputStream, nominally System.in
     * @return a line of text or null if end of stream.
     * @throws IOException
     */
    private static String readLine(InputStream in) throws IOException
    {
       StringBuilder sb = new StringBuilder();
       int readByte = in.read();
       while (readByte>-1 && readByte!= '\n')
       {
          sb.append((char) readByte);
          readByte = in.read();
       }
       return readByte==-1?null:sb.toString();

    }

}

সুন্দর অ্যানিমেশন, কৌতূহলের বাইরে আমার বটের আনুমানিক জয় শতাংশ কত?
রোহান ঝুনঝুনওয়ালা

আমি কোনও বাস্তব পরিসংখ্যান সম্পাদন করেছি না তবে আমি 60% আমার বট বনাম 40% আপনার বটকে বিপত্তি দেব? তবে সত্যিই
বারুদ স্থাপনের

ঠিক আছে, জিতে জিজি!
রোহান ঝুনঝুনওয়ালা

আমার আরও বেশি গোলাবারুদ থাকা উচিত, না আমি সমানভাবে স্পন করার জন্য গোলা বারুদ কনফিগার করব?
রোহান ঝুনঝুনওয়ালা

@ রোহানঝুনঝুনওয়ালা আমার মনে হয় এখনকার আচরণ পরিবর্তন করতে খুব দেরী হয়েছে what পরবর্তী প্রশ্ন জিজ্ঞাসা করার জন্য এটি শেখার অভিজ্ঞতা হিসাবে ব্যবহার করুন :)
মোগি

1

অপ্টিমাইজড পাথফাইন্ডার জেভিএ

আমার জগাখিচু প্লাবফিল পথচন্ডা অপ্টিমাইজ করতে সাহায্য করার জন্য @ মুগিকে ধন্যবাদ জানাই। এখানে বট জন্য উত্স। এই পতাকাটি জানে যে তার পতাকাটি রক্ষা করা কতটা গুরুত্বপূর্ণ। তিনি তিন ডিফেন্ডার এবং দুটি আক্রমণকারীকে বাদ দেন al ডিফেন্ডাররা পিছনে ঝুলতে থাকে এবং গোলাগুলি ডিফেন্ড করে / জড়ো করে, দু'জন আক্রমণকারী পতাকাটিতে যাওয়ার জন্য (মোটামুটি সোজা) পথ ধরে (এবং মাঝখানে গোলাগুলি সংগ্রহ করে)। তিনি যাকে দেখেন তাকে অঙ্কুরিত করে এবং তীব্র প্রতিযোগিতা হওয়া উচিত। ডিফেন্ডাররা পতাকা ও শিবিরের চারপাশে মাইন স্থাপন করে যতক্ষণ না কোনও বিরোধী না থাকে যাতে তারা যেতে পারে এবং লাথি মারতে পারে।

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 * todo fight
 */
package botctf;

import botctf.Move.MoveType;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

/**
 *
 * @author rohan
 */
public class PathFinderOptimised extends Bot {
    private static final int[][] offsets = new int[][]{{0,-1},{1,0},{0,1},{-1,0}};
    public static boolean shouldCampingTroll = true;
    private int moveCounter = -1;//dont ask
    public boolean defend;

    public PathFinderOptimised(int inX, int inY, int inTeam) {

        super(inX, inY, inTeam);
        //System.out.println("Start");
        //floodFillMap(getX(), getY());
        //System.out.println("Finish");
        defend=inX%2==0;
    }
    public static int[][] navigationMap;

    boolean upMine = false;
    boolean sideMine = false;

        int[][] myMap;

    @Override
    public Move move() {
                moveCounter++;
        myMap=getMap();
        int targetX, targetY;
        int enemyTeam=team==redTeam?blueTeam:redTeam;
        ArrayList<Coord> enemyCoordinates=new ArrayList<>();
        for(int i = 0; i<65;i++){
            for(int j = 0;j<65;j++){
                if(map[i][j]==enemyTeam){
                    enemyCoordinates.add(new Coord(i,j));
                }
            }
        }
        for(Coord enemy:enemyCoordinates){
            int enemyX=enemy.x;
            int enemyY=enemy.y;
         int dX= enemy.x-this.x;
            int dY= enemy.y-this.y;
            //System.out.println(dX+"|"+dY);
            if((dX==0||dY==0)){

                if(Arena.getAmmo()[this.team]>0){

                    if(dX>0&&dX<5){
                    return new Move(0,MoveType.Throw);
                }
                if(dX<0&&dX>-5){
                    return new Move(2,MoveType.Throw);
                }
                if (dY>0&&dY<5){
                    return new Move(1, MoveType.Throw);
                }
                if(dY<0&&dY>-5){
                    return new Move(3,MoveType.Throw);
                }
            }
        }
        }
        if(myMap[x+1][y]==ammo){
            return new Move(0,MoveType.Move);
        }
                if(myMap[x-1][y]==ammo){
            return new Move(2,MoveType.Move);
        }
                                if(myMap[x][y+1]==ammo){
            return new Move(1,MoveType.Move);
        }
                                                                if(myMap[x][y-1]==ammo){
            return new Move(3,MoveType.Move);
        }


int bestOption = 4;                                                             
        if (defend) {
if(Arena.getAliveBots()==1){
    defend=false;
}
            int bestAmmoX = -1;
            int bestAmmoY = -1;
            int bestAmmoDist = Integer.MAX_VALUE;
            for (int i = 0; i < 65; i++) {
                for (int j = 0; j < 65; j++) {
                    if (myMap[i][j] == ammo) {
                        int path = pathFind(getX(),getY(),i,j,myMap);
                        if ((path & 0xFFFFFF) < bestAmmoDist) {
                            bestAmmoX = i;
                            bestAmmoY = j;
                            bestAmmoDist = (path & 0xFFFFFF);
                            bestOption = path >> 24;
                        }
                    }
                }
            }
            if (bestAmmoDist<15||Arena.getAmmo()[this.team]==0){
                targetX = bestAmmoX;
                targetY = bestAmmoY;
            } else {
                targetX = team == redTeam ? 62 : 2;
                targetY = team == redTeam ? 62 : 2;
            }
        } else {

            if(this.x>18&this.x<42&&this.y>16&&this.y<44&&myMap[33][33]==ammo){
                targetX=33;
                targetY=33;
            }else{
            if (this.team == redTeam) {
                targetX = 1;
                targetY = 1;
            } else {
                targetX = 63;
                targetY = 63;
            }
            }
        }
        if(upMine&&sideMine){
            if(targetX==2||targetX==62){
                if(targetY==2||targetY==62){
                    targetX+=targetX==2?3:-3;
                    targetY+=targetY==2?3:-3;
                }
            }
        }else if (targetX == getX() && targetY == getY()) {
            if (!upMine) {
                upMine = true;
                if (this.team == redTeam) {
                    return new Move(0, MoveType.Mine);
                } else {
                    return new Move(2, MoveType.Mine);
                }
            }else if(!sideMine){
                sideMine=true;      
                if (this.team == redTeam) {
                    return new Move(1, MoveType.Mine);
                } else {
                    return new Move(3, MoveType.Mine);
                }
            }   else {
                return new Move(5, MoveType.Move);
            }
        }

        bestOption = pathFind(getX(),getY(),targetX,targetY,myMap) >> 24;


MoveType m=MoveType.Move;
if(moveCounter%2==0){
    if(this.team==redTeam?x<25&&y<25:x>39&&y>39){
        m=MoveType.Defuse;
    }
}
//System.out.println(bestOption);
        return new Move(bestOption, m);
    }

    /**
     * returns a result that is the combination of movement direction and length of a path found from the given start position to the target
     * position. result is ((direction) << 24 + path_length)
     */
    private int pathFind(int startX, int startY, int targetX,int targetY,int[][] map)
    {
        class PathSegment
        {
            public PathSegment(int tileX, int tileY, int fscore, int gscore, PathSegment parent)
            {
                super();
                this.tileX = tileX;
                this.tileY = tileY;
                this.fscore = fscore;
                this.gscore = gscore;
                this.parent = parent;
            }
            public PathSegment(PathSegment parent)
            {
                this.parent = parent;
            }
            int tileX;
            int tileY;
            int fscore;
            int gscore;
            PathSegment parent; 
        }
        // A*
        if (startX==targetX && startY==targetY)
        {
            return 4;
        }
        else
        {
            int[][] tileIsClosed = new int[64][64];

            PathSegment curSegment = new PathSegment(targetX,targetY,1,1,null);
            PathSegment newSegment;
            Set<PathSegment> openList = new HashSet<PathSegment>();
            openList.add(curSegment);

            do
            {
                if (openList.isEmpty())
                {
                    break;
                }
              PathSegment currentBestScoringSegment = openList.iterator().next();
              //  Look for the lowest F cost square on the open list
              for (PathSegment segment : openList)
              {
                if (segment.fscore<currentBestScoringSegment.fscore)
                {
                  currentBestScoringSegment = segment;
                }
              }
              curSegment = currentBestScoringSegment;

              // found path
              if (startX==curSegment.tileX && startY==curSegment.tileY)
              {
                break;
              }

              // if not in closed list
              if (tileIsClosed[curSegment.tileX][curSegment.tileY]==0)
              {
                    // Switch it to the closed list.
                    tileIsClosed[curSegment.tileX][curSegment.tileY]=1;
                    // remove from openlist
                    openList.remove(curSegment);


                    // add neigbours to the open list if necessary
                    for (int i=0;i<4;i++)
                    {
                        final int surroundingCurrentTileX=curSegment.tileX+offsets[i][0];
                        final int surroundingCurrentTileY=curSegment.tileY+offsets[i][1];
                        if (surroundingCurrentTileX>=0 && surroundingCurrentTileX<64 &&
                            surroundingCurrentTileY>=0 && surroundingCurrentTileY<64 )
                        {
                            newSegment = new PathSegment( curSegment);
                            newSegment.tileX = surroundingCurrentTileX;
                            newSegment.tileY = surroundingCurrentTileY;

                          if (map[surroundingCurrentTileX][surroundingCurrentTileY]=='W')
                          {
                              continue;
                          }

                          int surroundingCurrentGscore=curSegment.gscore+1;
                          newSegment.gscore=surroundingCurrentGscore;
                          newSegment.fscore=surroundingCurrentGscore+Math.abs( surroundingCurrentTileX-startX)+Math.abs( surroundingCurrentTileY-startY);
                          openList.add(newSegment);
                        }
                    }
              }
              else
              {
                  // remove from openlist
                  openList.remove(curSegment);    
              }
            } while(true);

            if (curSegment.parent.tileX-startX<0) return (2 << 24) | curSegment.gscore;
            else if (curSegment.parent.tileX-startX>0) return (0 << 24) | curSegment.gscore;
            else if (curSegment.parent.tileY-startY<0) return (3 << 24) | curSegment.gscore;
            else if (curSegment.parent.tileY-startY>0) return (1 << 24) | curSegment.gscore;
        }
        throw new RuntimeException("Path finding failed");
     }
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.