থ্রিডি: আলাদা ডগফাইটিং ডুয়েল (এখন জাভা নন সাবমিশনের জন্য উন্মুক্ত)


31

আপডেট: আইসুসিডিডাল () প্লেন ক্লাসে যুক্ত করা হয়েছিল, এটি আপনাকে প্লেনটি দেয়ালগুলির সাথে অপরিবর্তনীয় সংঘর্ষের কোর্সে রয়েছে কিনা তা পরীক্ষা করতে দেয়!

আপডেট: আপডেটকুলডাউন () সিমুলেটমভ () থেকে পৃথক

আপডেট: স্পার দ্বারা লিখিত জাভাবিহীন এন্ট্রি র‍্যাপার, পরীক্ষার জন্য উপলব্ধ, মন্তব্য দেখুন see

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

প্লেন ক্লাসের সিমুলেটমভ () ফাংশনটি কিছুটা সংশোধন করা হয়েছিল তাই এটি শীতল হওয়ার পরে আর আপডেট না করে, শুটিংয়ের পরে নতুন আপডেটকুলডাউন () ফাংশনটি ব্যবহার করুন। নতুন ইসসাইসিডাল () সত্য প্রত্যাবর্তন করে যদি কোনও প্লেন মৃতপ্রায় হয়ে যেতে বাধ্য হয়, শত্রুদের চালগুলি ছাঁটাই করতে এবং প্রাচীরকে আঘাত করা এড়াতে এটি ব্যবহার করুন। আপডেট হওয়া কোডটি পেতে, গিথুব রেপোগুলিতে কেবল কন্ট্রোলার এবং প্লেন ক্লাসগুলি প্রতিস্থাপন করুন

বিবরণ

এই চ্যালেঞ্জের লক্ষ্য হ'ল দুটি ডগফাইটিং প্লেনকে কোড করা যা অন্য প্রতিযোগীর দ্বারা দুটি প্লেনের বিরুদ্ধে মুখোমুখি হবে। প্রতিটি পালা আপনি একটি স্থান সরানো এবং অঙ্কুর করার সুযোগ আছে। এটাই, এটি এতটা সহজ।

ভাল প্রায়...

এরিনা এবং সম্ভাব্য পদক্ষেপ

মহাকাশে প্রাচীরটি একটি 14x14x14 প্রাচীর। প্রতিযোগী 1 এর প্লেনগুলি অবস্থানগুলি (0,5,0) এবং (0,8,0) এবং প্রতিযোগী 2 এর (13,5,13) এবং (13,8,13) থেকে শুরু হয়। সমস্ত প্লেনগুলি যার কাছাকাছি অবস্থিত উল্লম্ব দেয়ালগুলি থেকে অনুভূমিকভাবে উড়ে গিয়ে শুরু হয়।

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

সম্ভাব্য দিকনির্দেশগুলি হ'ল: উত্তর (এন), দক্ষিণ (এস), পূর্ব (ই), পশ্চিম (ডাব্লু), আপ (ইউ) এবং ডাউন (ডি) এবং এই ছয়টির যে কোনও যৌক্তিক সমন্বয়। যেখানে এনএস অক্ষটি এক্স অক্ষের সাথে মিলে যায়, ডব্লিউই থেকে y এবং ডিইউ থেকে জেড। NW, SU এবং NED দিকনির্দেশের সম্ভাব্য উদাহরণ হিসাবে মনে আসে; ইউডি একটি অবৈধ সংমিশ্রণের দুর্দান্ত উদাহরণ।

আপনি অবশ্যই আপনার বিমানগুলির দিক পরিবর্তন করতে পারেন, তবে একটি সীমাবদ্ধতা রয়েছে, আপনি কেবলমাত্র সর্বোচ্চ 45 ডিগ্রি দ্বারা আপনার দিক পরিবর্তন করতে পারেন। এটি দেখতে, আপনার রুবিকের ঘনক্ষেতটি ধরুন (আমি জানি আপনার একটি রয়েছে) এবং কল্পনা করুন যে ২ outer টি বাহ্যিক ছোট ঘনক্ষেত্রের সমস্তই সম্ভাব্য দিকনির্দেশনা (একটি অক্ষরের দিক মুখ, দুটি অক্ষরের দিক প্রান্ত এবং তিনটি অক্ষরের দিক কোণ)। আপনি যদি সামান্য ঘনক্ষেত্র দ্বারা প্রতিনিধিত্ব করা কোনও দিকে যাচ্ছেন তবে আপনি নিজের স্পর্শের প্রতিটি ঘনকের দিকে দিক পরিবর্তন করতে পারবেন (তির্যকভাবে স্পর্শকারী গণনাগুলি, তবে কেবল স্পর্শকাতরভাবে স্পর্শ করা, এটি কিউবটি স্পর্শ করছে না)।

সমস্ত প্লেনগুলি কোন দিকে পরিবর্তন করতে চায় তার দিকে ইঙ্গিত করার পরে তারা তা করে এবং একই সাথে একটি টাইল সরিয়ে দেয়।

আপনি কোনও বৈধ দিকে যাওয়ার দিকেও যেতে পারেন তবে আপনি যে দিকে যাচ্ছেন সেদিকে আপনার দিক পরিবর্তন করার পরিবর্তে আপনি যে দিকে যাচ্ছেন সেদিকেই উড়তে থাকুন। এটি একটি কোণার কাছাকাছি যাওয়া গাড়ি এবং একটি গাড়ি পরিবর্তনকারী লেনের পার্থক্যের সাথে সাদৃশ্য।

শুটিং এবং মরণ

আপনি প্রতি রাউন্ডে একবারে গুলি করতে পারেন এবং ঠিক একই সময়ে সিদ্ধান্ত নেওয়া উচিত যে আপনি কোন দিকটি উড়তে হবে এবং আপনি নিজের বিমানটি (এবং এক্সটেনশনের মাধ্যমে, আপনার বন্দুকটি) একই দিকে নির্দেশিত রাখতে চান কিনা তা ঠিক করুন। বুলেটটি আপনার বিমানটি চলার ঠিক পরে গুলিবিদ্ধ হয়। শুটিংয়ের পরে এক পালা শীতল ডাউন আছে, তৃতীয় টার্নে, আপনি আবার যেতে ভাল good আপনি কেবল যে দিকে যাত্রা করছেন সেদিকেই গুলি করতে পারেন A একটি বুলেট তাত্ক্ষণিক হয় এবং এটি কোনও দেয়াল বা বিমানকে আঘাত না করা পর্যন্ত একটি সরলরেখায় উড়ে যায়।

আপনি যেভাবে দিক পরিবর্তন করতে পারেন তেমন 'লেন পরিবর্তন করুন' তা বিবেচনায় নিয়ে আসার অর্থ এই যে আপনি আপনার সামনে 3x3 লাইন পর্যন্ত একটি কলামকে অতিরিক্ত কিছু তির্যক, একক লাইনকে হুমকি দিতে পারেন।

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

দুটি প্লেন অবশ্য সংঘর্ষে পড়তে পারে (যদি তারা একই ঘনক্ষেত্রের মধ্যে শেষ হয় এবং যদি তারা একই বিমানে শেষ না করে একে অপরকে অতিক্রম করে তবে) এবং এর ফলে উভয় বিমান মারা যায় (এবং সম্পূর্ণ বিস্ফোরিত হয়)। আপনি প্রাচীরের মধ্যেও উড়ে যেতে পারেন যার ফলে বিমানটি প্রশ্নোত্তর হয়ে উঠবে এবং এর ক্রিয়াগুলি সম্পর্কে চিন্তা করতে কোণায় ফেলে দেওয়া হবে। সংঘর্ষগুলি শুটিংয়ের আগে পরিচালনা করা হয়।

নিয়ন্ত্রকের সাথে যোগাযোগ

আমি জাভা এবং অন্যান্য ভাষায় এন্ট্রি গ্রহণ করব। যদি আপনার এন্ট্রি জাভাতে থাকে, আপনি এসটিডিআইএন এর মাধ্যমে ইনপুট পাবেন এবং এসটিডিআউট মাধ্যমে আউটপুট পাবেন।

যদি আপনার এন্ট্রি জাভাতে থাকে, .আপনার প্রবেশ অবশ্যই নিম্নলিখিত শ্রেণীর প্রসারিত করতে হবে:

package Planes;

//This is the base class players extend.
//It contains the arena size and 4 plane objects representing the planes in the arena.
public abstract class PlaneControl {

    // note that these planes are just for your information, modifying these doesn't affect the actual plane instances, 
    // which are kept by the controller
    protected Plane[] myPlanes = new Plane[2];
    protected Plane[] enemyPlanes = new Plane[2];
    protected int arenaSize;
    protected int roundsLeft;

    ...

    // Notifies you that a new fight is starting
    // FightsFought tells you how many fights will be fought.
    // the scores tell you how many fights each player has won.
    public void newFight(int fightsFought, int myScore, int enemyScore) {}

    // notifies you that you'll be fighting anew opponent.
    // Fights is the amount of fights that will be fought against this opponent
    public void newOpponent(int fights) {}

    // This will be called once every round, you must return an array of two moves.
    // The move at index 0 will be applied to your plane at index 0,
    // The move at index1 will be applied to your plane at index1.
    // Any further move will be ignored.
    // A missing or invalid move will be treated as flying forward without shooting.
    public abstract Move[] act();
}

এই শ্রেণীর তৈরি করা দৃষ্টান্তটি পুরো প্রতিযোগিতা জুড়ে থাকবে, যাতে আপনি ভেরিয়েবলগুলিতে সঞ্চয় করতে চান এমন কোনও ডেটা সংরক্ষণ করতে পারেন। আরও তথ্যের জন্য কোডটিতে মন্তব্য পড়ুন।

আমি আপনাকে নিম্নলিখিত সহায়ক ক্লাসগুলি সরবরাহ করেছি:

package Planes;

//Objects of this class contain all relevant information about a plane
//as well as some helper functions.
public class Plane {
    private Point3D position;
    private Direction direction;
    private int arenaSize;
    private boolean alive = true;
    private int coolDown = 0;

    public Plane(int arenaSize, Direction direction, int x, int y, int z) {}

    public Plane(int arenaSize, Direction direction, Point3D position) {}    

    // Returns the x coordinate of the plane
    public int getX() {}

    // Returns the y coordinate of the plane
    public int getY() {}

    // Returns the z coordinate of the plane
    public int getZ() {}

    // Returns the position as a Point3D.
    public Point3D getPosition() {}

    // Returns the distance between the plane and the specified wall,
    // 0 means right next to it, 19 means at the opposite side.
    // Returns -1 for invalid input.
    public int getDistanceFromWall(char wall) {}

    // Returns the direction of the plane.
    public Direction getDirection() {}

    // Returns all possible turning directions for the plane.
    public Direction[] getPossibleDirections() {}

    // Returns the cool down before the plane will be able to shoot, 
    // 0 means it is ready to shoot this turn.
    public int getCoolDown() {}

    public void setCoolDown(int coolDown) {}

    // Returns true if the plane is ready to shoot
    public boolean canShoot() {}

    // Returns all positions this plane can shoot at (without first making a move).
    public Point3D[] getShootRange() {}

    // Returns all positions this plane can move to within one turn.
    public Point3D[] getRange() {}

    // Returns a plane that represents this plane after making a certain move,
    // not taking into account other planes.
    // Doesn't update cool down, see updateCoolDown() for that.
    public Plane simulateMove(Move move) {}

    // modifies this plane's cool down
    public void updateCoolDown(boolean shot) {
        coolDown = (shot && canShoot())?Controller.COOLDOWN:Math.max(0, coolDown - 1);
    }


    // Returns true if the plane is alive.
    public boolean isAlive() {}

    // Sets alive to the specified value.
    public void setAlive(boolean alive) {}

    // returns a copy of itself.
    public Plane copy() {}

    // Returns a string representing its status.
    public String getAsString() {}

    // Returns a string suitable for passing to a wrapped plane process
    public String getDataString() {}

    // Returns true if a plane is on an irreversable colision course with the wall.
    // Use this along with simulateMove() to avoid hitting walls or prune possible emeny moves.
    public boolean isSuicidal() {}
}


// A helper class for working with directions. 
public class Direction {
    // The three main directions, -1 means the first letter is in the direction, 1 means the second is, 0 means neither is.
    private int NS, WE, DU;

    // Creates a direction from 3 integers.
    public Direction(int NSDir, int WEDir, int DUDir) {}

    // Creates a direction from a directionstring.
    public Direction(String direction) {}

    // Returns this direction as a String.
    public String getAsString() {}

    // Returns The direction projected onto the NS-axis.
    // -1 means heading north.
    public int getNSDir() {}

    // Returns The direction projected onto the WE-axis.
    // -1 means heading west.
    public int getWEDir() {}

    // Returns The direction projected onto the DU-axis.
    // -1 means heading down.
    public int getDUDir() {}

    // Returns a Point3D representing the direction.
    public Point3D getAsPoint3D() {}

    // Returns an array of chars representing the main directions.
    public char[] getMainDirections() {}

    // Returns all possible turning directions.
    public Direction[] getPossibleDirections() {}

    // Returns true if a direction is a valid direction to change to
    public boolean isValidDirection(Direction direction) {}
}

public class Point3D {
    public int x, y, z;

    public Point3D(int x, int y, int z) {}

    // Returns the sum of this Point3D and the one specified in the argument.
    public Point3D add(Point3D point3D) {}

    // Returns the product of this Point3D and a factor.
    public Point3D multiply(int factor) {}

    // Returns true if both Point3D are the same.
    public boolean equals(Point3D point3D) {}

    // Returns true if Point3D is within a 0-based arena of a specified size.
    public boolean isInArena(int size) {}
}


public class Move {
    public Direction direction;
    public boolean changeDirection;
    public boolean shoot;

    public Move(Direction direction, boolean changeDirection, boolean shoot) {}
}

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

আপনার এন্ট্রিটি দেখতে কেমন হতে পারে তার একটি উদাহরণ এখানে রয়েছে (আশা করি আপনি আমার চেয়ে আরও ভাল করতে পারছেন , প্রাচীর এড়াতে তাদের সর্বোত্তম প্রচেষ্টা সত্ত্বেও এই বিমানগুলির সাথে বেশিরভাগ ম্যাচগুলি প্রাচীরের সাথে উড়ে যাওয়ার সাথে শেষ হয়)):

package Planes;

public class DumbPlanes extends PlaneControl {

    public DumbPlanes(int arenaSize, int rounds) {
        super(arenaSize, rounds);
    }

    @Override
    public Move[] act() {
        Move[] moves = new Move[2];
        for (int i=0; i<2; i++) {
            if (!myPlanes[i].isAlive()) {
                moves[i] = new Move(new Direction("N"), false, false); // If we're dead we just return something, it doesn't matter anyway.
                continue;
            }
            Direction[] possibleDirections = myPlanes[i].getPossibleDirections(); // Let's see where we can go.

            for (int j=0; j<possibleDirections.length*3; j++) {

                int random = (int) Math.floor((Math.random()*possibleDirections.length)); // We don't want to be predictable, so we pick a random direction out of the possible ones.

                if (myPlanes[i].getPosition().add(possibleDirections[random].getAsPoint3D()).isInArena(arenaSize)) { // We'll try not to fly directly into a wall.
                    moves[i] = new Move(possibleDirections[random], Math.random()>0.5, myPlanes[i].canShoot() && Math.random()>0.2);
                    continue; // I'm happy with this move for this plane.
                }

                // Uh oh.
                random = (int) Math.floor((Math.random()*possibleDirections.length));
                moves[i] = new Move(possibleDirections[random], Math.random()>0.5, myPlanes[i].canShoot() && Math.random()>0.2);
            }
        }

        return moves;
    }

    @Override
    public void newFight(int fightsFought, int myScore, int enemyScore) {
        // Using information is for schmucks.
    }

    @Override
    public void newOpponent(int fights) {
        // What did I just say about information?
    }
}

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

বিধিনিষেধ

KOTH উইকিতে উল্লিখিত বিধিনিষেধগুলি প্রযোজ্য:

  • নিয়ামক, রানটাইম বা অন্যান্য সাবমিশনগুলির সাথে টিঙ্কার করার যে কোনও প্রয়াস অযোগ্য ঘোষণা করা হবে। সমস্ত সাবমিশনগুলি কেবলমাত্র প্রদত্ত ইনপুট এবং স্টোরেজগুলির সাথে কাজ করা উচিত।
  • নির্দিষ্ট অন্যান্য বটগুলিকে বীট বা সমর্থন করতে বটগুলি লেখা উচিত নয়। (বিরল ক্ষেত্রে এটি আকাঙ্ক্ষিত হতে পারে, তবে এটি যদি চ্যালেঞ্জের মূল ধারণা না হয় তবে এটিকে আরও ভালভাবে উড়িয়ে দেওয়া হবে))
  • আমি যুক্তিগুলিকে অযোগ্য করার অধিকার সংরক্ষণ করি যেগুলি যুক্তিসঙ্গত পরিমাণ সংস্থান দিয়ে ট্রায়াল চালাতে খুব বেশি সময় বা মেমরি ব্যবহার করে।
  • একটি বট ইচ্ছাকৃতভাবে বা দুর্ঘটনাক্রমে কোনও বিদ্যমান কৌশল হিসাবে ঠিক একই কৌশলটি প্রয়োগ করতে পারে না।

আপনার জমা দেওয়ার পরীক্ষা করা হচ্ছে

এখান থেকে নিয়ামক কোডটি ডাউনলোড করুন । সামথিংজভা হিসাবে আপনার জমা দিন। আপনার প্লেনের জন্য []] এবং নামগুলিতে প্রবেশের জন্য কন্ট্রোলার.জেভা পরিবর্তন করুন] Eclipse প্রজেক্ট বা এর সাথে সবকিছু সংকলন করুন javac -d . *.java, তারপরে কন্ট্রোলারটি চালান java Planes/Controller। প্রতিযোগিতার একটি লগ থাকবে test.txtশেষে, স্কোরবোর্ড সহ। matchUp()একে অপরের বিরুদ্ধে দুটি প্লেন পরীক্ষা করার জন্য আপনি দুটি এন্ট্রি দিয়ে সরাসরি কল করতে পারেন ments

লড়াই জিতেছে

লড়াইয়ের বিজয়ী হলেন যিনি শেষ বিমানটি উড়াল করেছেন, যদি 100 টার্ন পরে, এখনও 1 টিরও বেশি দল বাকি রয়েছে, সর্বাধিক প্লেনসম্পন্ন দলটি জিতেছে। এটি সমান হলে এটি একটি ড্র draw

স্কোরিং এবং প্রতিযোগিতা

বর্তমান অনুগ্রহ শেষ হয়ে গেলে পরবর্তী অফিশিয়াল টুর্নামেন্টটি চালানো হবে।

প্রতিটি এন্ট্রি প্রতিটি অন্যান্য এন্ট্রি (কমপক্ষে) 100 বার লড়াই করবে, প্রতিটি ম্যাচ আপের বিজয়ী 100 এর মধ্যে সবচেয়ে বেশি বিজয়ী এবং 2 পয়েন্ট দেওয়া হবে awarded ড্রয়ের ক্ষেত্রে উভয় এন্ট্রিকে ১ পয়েন্ট দেওয়া হয়।

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

এন্ট্রিগুলির পরিমাণের উপর নির্ভর করে, এন্ট্রিগুলির মধ্যে মারামারিগুলির পরিমাণ উল্লেখযোগ্যভাবে বাড়ানো যেতে পারে, আমি প্রথম টুর্নামেন্টের পরে ২-৪টি সেরা এন্ট্রিগুলিও বেছে নিতে পারি এবং আরও লড়াইয়ের সাথে এন্ট্রিগুলির মধ্যে একটি এলিট টুর্নামেন্ট স্থাপন করতে পারি (এবং সম্ভবত প্রতি রাউন্ডে আরও রাউন্ড) যুদ্ধ)

(প্রাথমিক) স্কোরবোর্ড

আমরা একটি নতুন এন্ট্রি পেয়েছি যারা দৃ another়ভাবে অন্য একটি উত্তেজনাপূর্ণ টুর্নামেন্টে দ্বিতীয় স্থান অর্জন করেছে , দেখে মনে হচ্ছে ক্রসফায়ার প্রিডিক্ট অ্যান্ড অ্যাভিড ব্যতীত সবার জন্য গুলি করা অবিশ্বাস্যরকম কঠিন। নোট করুন যে এই টুর্নামেন্টটি প্রতিটি প্লেনের মধ্যে কেবল 10 টি মারামারি নিয়ে পরিচালিত হয়েছিল এবং এরপরে কীভাবে পরিস্থিতি দাঁড়ায় তার পুরোপুরি সঠিক উপস্থাপনা নেই।

----------------------------
¦ 1. PredictAndAvoid:   14 ¦
¦ 2. Crossfire:         11 ¦
¦ 3. Weeeeeeeeeeee:      9 ¦
¦ 4. Whirligig:          8 ¦
¦ 4. MoveAndShootPlane:  8 ¦
¦ 6. StarFox:            4 ¦
¦ 6. EmoFockeWulf:       2 ¦
¦ 7. DumbPlanes:         0 ¦
----------------------------

নন-জাভা র‍্যাপার থেকে আউটপুট দেওয়ার উদাহরণ এখানে দেওয়া হয়েছে:

NEW CONTEST 14 20 ইঙ্গিত দেয় যে একটি 14x14x14 অঙ্গনে একটি নতুন প্রতিযোগিতা শুরু হচ্ছে এবং এতে প্রতি লড়াইয়ে 20 টি জড়িত থাকবে।

NEW OPPONENT 10 আপনি নতুন প্রতিপক্ষের মুখোমুখি হয়ে আছেন এবং আপনি এই প্রতিপক্ষের সাথে 10 বার লড়াই করবেন বলে ইঙ্গিত দেয়

NEW FIGHT 5 3 2 ইঙ্গিত দেয় যে বর্তমান প্রতিপক্ষের বিরুদ্ধে একটি নতুন লড়াই শুরু হচ্ছে, আপনি এখন পর্যন্ত 5 বার এই প্রতিপক্ষের সাথে লড়াই করেছেন, 3 জিতে এবং 2 টি লড়াই হেরে গেছেন

ROUNDS LEFT 19 ইঙ্গিত দেয় যে বর্তমান লড়াইয়ে 19 রাউন্ড বাকি আছে

NEW TURN ইঙ্গিত দেয় যে আপনি লড়াইয়ের এই রাউন্ডের জন্য চারটি প্লেনের ডেটা পেতে চলেছেন

alive 13 8 13 N 0
alive 13 5 13 N 0
dead 0 0 0 N 0
alive 0 8 0 S 0

এই চারটি লাইন ইঙ্গিত দেয় যে আপনার উভয় বিমানই যথাক্রমে [13,8,13] এবং [13,5,13] স্থানাঙ্কগুলিতে, উভয়ই উত্তরমুখী, উভয়ই শূন্য কোলডাউন সহ। প্রথম শত্রু বিমানটি মারা গেছে এবং দ্বিতীয়টি জীবিত রয়েছে [0,8,0] এ এবং শূন্য কোলডাউন সহ দক্ষিণের দিকে মুখ করে।

এই মুহুর্তে আপনার প্রোগ্রামটি নীচের মত দুটি লাইন আউটপুট করা উচিত:

NW 0 1
SU 1 0

এটি ইঙ্গিত দেয় যে আপনার প্রথম সমতলটি বর্তমান শিরোনামটি না ঘুরিয়ে, এবং সক্ষম হলে শুটিং করে উত্তর-পশ্চিম ভ্রমণ করবে। আপনার দ্বিতীয় বিমানটি সাউথআপ ভ্রমণ করবে, শুটিং নয়, সাউথআপের মুখোমুখি হবে।

এখন আপনি ইত্যাদি ROUNDS LEFT 18অনুসরণ করুন NEW TURNএটি অব্যাহত থাকে যতক্ষণ না কেউ জেতে বা রাউন্ড টাইম আউট হয়ে যায়, এমন সময়ে আপনি NEW FIGHTআপডেট হওয়া লড়াইয়ের গণনা এবং স্কোরগুলির সাথে আরও একটি লাইন পাবেন সম্ভবত সম্ভবত এর আগে NEW OPPONENT


কারও যদি এই চ্যালেঞ্জটি নিয়ে সহায়তা প্রয়োজন, আপনি এই চ্যালেঞ্জটির জন্য আমি
ওভাররেেক্টর

বিমানগুলি কি পূর্ব / পশ্চিম বা উত্তর / দক্ষিণের দিকে যাত্রা শুরু করে? অথবা অন্য কিছু?
ছদ্মনাম

2
@ প্রেমিক কোলডাউন কোডে একটি বাগ আছে। আপনি "নতুন অবস্থানের গণনা করুন" বিভাগে সিমুলেটমোভ ব্যবহার করছেন, যা নতুন অবস্থানগুলি সন্ধানের পাশাপাশি কলোডাউন হ্রাস পেয়েছে। এর অর্থ কোনও প্লেন যদি তাদের নিজস্ব কলোডাউন কাউন্টার উপেক্ষা করে তবে প্রতিটি পালা গুলি চালাতে পারে।
স্পার

2
যারা এটি দরকারী হিসাবে পেতে পারেন তাদের জন্য এই রেজেেক্স লগের মাধ্যমে অনুসন্ধান করবে যেখানে আপনার বিমানটি যেখানে ^ মুভ (। *?) অঙ্কুর: সত্য $ (আপনার নামের সাথে "সরান" প্রতিস্থাপন করে এবং এটি নিশ্চিত করে যে নতুনটি ক্যাপচার করে না লাইনগুলি
ব্যবহারকারী 2813274

1
বোবা পাইথন বিমান সহ আমার বিমানের মোড়কের জন্য এখানে একটি প্রতিশ্রুতি দেওয়া আছে। যদি আমি পার্ল / পাইথন / লুয়া / বাশ / যাই হোক না কেন কোনও স্মার্ট প্লেন লিখতে পারি এবং আমাকে / কীভাবে আপনার জন্য র‌্যাপার কাজ করে তা সম্পর্কে কিছু প্রতিক্রিয়া জানাতে চাই I'd github.com/sparr/Dogfight-KOTH/commit/… লোকেরা যদি এটি ব্যবহার করতে পারে / ব্যবহার করতে পারে তবে আমরা এটি @ ওভারেক্টরের রেপোতে উঠতে পারি এবং নির্বিচারে ভাষা জমা দেওয়ার অনুমতি দিতে পারি।
স্পার

উত্তর:


5

গোলাগুলিবিনিময়

আমার প্রাথমিক ধারণাটি ছিল একই সাথে আমার দু'টি বিমানের সাথে শত্রু বিমান চালানো, তবে আমি এটি কার্যকর করতে পারিনি ... সুতরাং এখানে এমন একটি বিমান রয়েছে যা দেয়াল থেকে দূরে থাকতে এবং শুটিংয়ের পরিসর থেকে দূরে থাকতে চেষ্টা করে শত্রু। প্লেনগুলির কখনই সংঘর্ষ বা বন্ধুত্বপূর্ণ বিমানগুলি চালানো উচিত নয়।

সম্পাদনা করুন: পদ্ধতিটি possibleHitsঠিক করে দেওয়ার পরে এবং বেশ কয়েকটি সামান্য উন্নতি যোগ করার পরে সর্বদা 0 ফিরে আসে, এটি আগের চেয়ে ভাল সম্পাদন করে।

package Planes;

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

public class Crossfire extends PlaneControl {
    final List<Point3D> dangerList = new ArrayList<>(); //danger per point
    final List<Plane> targets = new ArrayList<>(); //targets being shot
    Plane[] futurePlanes = null; //future friendly planes

    public Crossfire(int arenaSize, int rounds) {
        super(arenaSize, rounds);
    }

    @Override
    public Move[] act() {
        dangerList.clear();     //initialize
        targets.clear();
        final int PLANE_COUNT = myPlanes.length;
        Move[] moves = new Move[PLANE_COUNT];
        futurePlanes = new Plane[PLANE_COUNT];

        // calculate danger per field/enemy
        for (int i = 0; i < PLANE_COUNT; i++) {
            updateDanger(enemyPlanes[i]);
        }   

        // get best moves for each plane
        for (int i = 0; i < PLANE_COUNT; i++) {         
            moves[i] = getBestMove(myPlanes[i]);
            futurePlanes[i] = myPlanes[i].simulateMove(moves[i]);
            updateTargets(futurePlanes[i]);
        }

        // try to shoot if no friendly plane is hit by this bullet
        for (int i = 0; i < myPlanes.length; i++) {
            if (myPlanes[i].canShoot() && canShootSafely(futurePlanes[i]) && possibleHits(futurePlanes[i]) > 0) {
                moves[i].shoot = true;
            }
        }

        return moves;
    }

    private void updateTargets(Plane plane) {
        if (!plane.canShoot() || !canShootSafely(plane)) {
            return;
        }
        Point3D[] range = plane.getShootRange();
        for (Plane enemyPlane : enemyPlanes) {
            for (Move move : getPossibleMoves(enemyPlane)) {
                Plane simPlane = enemyPlane.simulateMove(move);
                for (Point3D dest : range) {
                    if (dest.equals(simPlane.getPosition())) {
                        targets.add(enemyPlane);
                    }
                }
            }           
        }
    }

    private void updateDanger(Plane plane) {
        if (!plane.isAlive()) {
            return;
        }
        for (Move move : getPossibleMoves(plane)) {
            Plane futurePlane = plane.simulateMove(move);
            // add position (avoid collision)
            if (!isOutside(futurePlane)) {
                dangerList.add(futurePlane.getPosition());
                // avoid getting shot
                if (plane.canShoot()) {
                    for (Point3D dest : futurePlane.getShootRange()) {
                        dangerList.add(dest);
                    }
                }
            }
        }
    }

    private Move getBestMove(Plane plane) {
        if (!plane.isAlive()) {
            return new Move(new Direction("N"), false, false);
        }

        int leastDanger = Integer.MAX_VALUE;
        Move bestMove = new Move(new Direction("N"), false, false);
        for (Move move : getPossibleMoves(plane)) {
            Plane futurePlane = plane.simulateMove(move);
            int danger = getDanger(futurePlane) - (possibleHits(futurePlane) *2);
            if (danger < leastDanger) {
                leastDanger = danger;
                bestMove = move;
            }
        }
        return bestMove;
    }

    private int getDanger(Plane plane) {
        if (!plane.isAlive() || hugsWall(plane) || collidesWithFriend(plane) || isOutside(plane)) {
            return Integer.MAX_VALUE - 1;
        }
        int danger = 0;
        Point3D pos = plane.getPosition();
        for (Point3D dangerPoint : dangerList) {
            if (pos.equals(dangerPoint)) {
                danger++;
            }
        }
        // stay away from walls
        for (char direction : plane.getDirection().getMainDirections()) {
            if (plane.getDistanceFromWall(direction) <= 2) {
                danger++;
            }
        }
        return danger;
    }

    private boolean collidesWithFriend(Plane plane) {
        for (Plane friendlyPlane : futurePlanes) {
            if (friendlyPlane != null && plane.getPosition().equals(friendlyPlane.getPosition())) {
                return true;
            }
        }
        return false;
    }

    private boolean hugsWall(Plane plane) {
        if (!plane.isAlive() || isOutside(plane)) {
            return true;
        }
        char[] mainDirs = plane.getDirection().getMainDirections();
        if (mainDirs.length == 1) {
            return plane.getDistanceFromWall(mainDirs[0]) == 0;
        }
        if (mainDirs.length == 2) {
            return plane.getDistanceFromWall(mainDirs[0]) <= 1
                    && plane.getDistanceFromWall(mainDirs[1]) <= 1;
        }
        if (mainDirs.length == 3) {
            return plane.getDistanceFromWall(mainDirs[0]) <= 1
                    && plane.getDistanceFromWall(mainDirs[1]) <= 1
                    && plane.getDistanceFromWall(mainDirs[2]) <= 1;
        }
        return false;
    }

    private Set<Move> getPossibleMoves(Plane plane) {
        Set<Move> possibleMoves = new HashSet<>();
        for (Direction direction : plane.getPossibleDirections()) {
            possibleMoves.add(new Move(direction, false, false));
            possibleMoves.add(new Move(direction, true, false));
        }
        return possibleMoves;
    }

    private boolean canShootSafely(Plane plane) {
        if (!plane.canShoot() || isOutside(plane)) {
            return false;
        }
        for (Point3D destPoint : plane.getShootRange()) {
            for (Plane friendlyPlane : futurePlanes) {
                if (friendlyPlane == null) {
                    continue;
                }
                if (friendlyPlane.isAlive() && friendlyPlane.getPosition().equals(destPoint)) {
                    return false;
                }
            }
        }
        return true;
    }

    private int possibleHits(Plane plane) {
        if (!plane.canShoot() || !canShootSafely(plane)) {
            return 0;
        }
        int possibleHits = 0;
        Point3D[] range = plane.getShootRange();
        for (Plane enemyPlane : enemyPlanes) {
            for (Move move : getPossibleMoves(enemyPlane)) {
                Plane simPlane = enemyPlane.simulateMove(move);
                for (Point3D dest : range) {
                    if (dest.equals(simPlane.getPosition())) {
                        possibleHits++;
                    }
                }
            }           
        }
        return possibleHits;
    }

    private boolean isOutside(Plane plane) {
        return !plane.getPosition().isInArena(arenaSize);
    }
}

1
প্রডিক্ট অ্যান্ড অ্যাওয়েডের পরে আপনি এখন দ্বিতীয় সেরা এন্ট্রি। আপনি অন্য প্রতিটি প্রবেশের বিরুদ্ধে জিততে পারেন, তবে বেশ অনেকটা আঁকুন। প্রিডিক্ট অ্যান্ডঅভিডের বিপরীতে, ভর্লিগিগ আপনার চেয়ে বেশি জয় এবং ড্রয়ের প্রয়োগ করতে পরিচালিত করে। নির্বিশেষে ভাল প্রবেশ!
ওভাররেક્ટર

1
@ বিনিয়োগকারী আপনার ইনপুট জন্য আপনাকে ধন্যবাদ! তার মানে আমাকে শুটিং-
পার্টে

1
আমি আরও কিছু পরীক্ষা করেছি, দেখে মনে হচ্ছে আপনি প্রিডিক্ট অ্যান্ড অ্যাভিডের চেয়ে ভারিলিগের বিপক্ষে হেরে গেছেন, প্রিডিক্ট অ্যান্ড অ্যাওয়েড আরও জয়ের ব্যবস্থা করে নিলেও, এখানে 2000 মারামারি সম্পর্কিত ডেটা রয়েছে: প্রিডিক্ট অ্যান্ডএভিড: 1560 হুইলিগিগ: 138 | ভবিষ্যদ্বাণী এবং এ্যাওয়েড: 1564 ক্রসফায়ার: 125 | ঘূর্ণিঝড়: 25 ক্রসফায়ার: 600
ওভাররেક્ટર

@ প্রেমিক আমার জমাটি উন্নত করার জন্য সময় খুঁজে পেয়েছেন। এখন, এটি কখনও কখনও প্রিডিক্টঅ্যান্ডএভিডের বিরুদ্ধে জয়ী হয়, ড্র করে এবং হারাবে।
কমনগ্যুই

1
10,000 টি মারামারি শেষে ভাল হয়েছে: এসসিওআর: প্রেডিক্ট অ্যান্ডএভিড: 1240 ক্রসফায়ার: 6567
ওভারটেক্টর

20
/*
    PREDICT AND AVOID

    Rules of behavior:
    - Avoid hitting walls
    - Move, safely, to shoot at spaces our enemy might fly to
    - (contingent) Move to a safe space that aims closer to the enemy
    - Move to a safe space
    - Move, unsafely, to shoot at spaces our enemy might fly to
    - Move to any space (remember to avoid walls)

    Chooses randomly between equally prioritized moves

    contingent strategy is evaluated during early fights
*/

package Planes;

import java.util.Random;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;


public class PredictAndAvoid extends PlaneControl {

    public PredictAndAvoid(int arenaSize, int rounds) {
        super(arenaSize, rounds);
    }


    private int fightsPerMatch = 0;
    private int fightNum = 0;
    private int roundNum = 0;
    private boolean useHoming = true;
    private int homingScore = 0;
    private int[][][] enemyHistory = new int[arenaSize][arenaSize][arenaSize];

    // don't need to take roots here, waste of cpu cycles
    int distanceCubed(Point3D a, Point3D b) {
        return (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) + (a.z-b.z)*(a.z-b.z);
    }

    // is this plane guaranteed to hit a wall, now or soon?
    boolean dangerZone(Plane icarus) {
        // outside the arena?
        // already dead
        // this should never happen for my planes
        if (!icarus.getPosition().isInArena(arenaSize)) {
            return true;
        }
        // adjacent to a wall?
        // directly facing the wall?
        // death next turn
        if (
            icarus.getDirection().getMainDirections().length==1 &&
            icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[0]) == 0
        ) {
                return true;
        }
        // on an edge?
        // 2d diagonal facing into that edge?
        // death next turn
        if (
            icarus.getDirection().getMainDirections().length==2 &&
            icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[0]) == 0 &&
            icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[1]) == 0
        ) {
                return true;
        }
        // near a corner?
        // 3d diagonal facing into that corner?
        // death in 1-2 turns
        if (
            icarus.getDirection().getMainDirections().length==3 &&
            icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[0]) < 2 &&
            icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[1]) < 2 &&
            icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[2]) < 2
        ) {
                return true;
        }
        // there's at least one way out of this position
        return false;
    }

    @Override
    public Move[] act() {
        Move[] moves = new Move[2];

        for (int i=0; i<2; i++) {
            Plane p = myPlanes[i];
            if (!p.isAlive()) {
                moves[i] = new Move(new Direction("N"), false, false); // If we're dead we just return something, it doesn't matter anyway.
                continue;
            }

            // a list of every move that doesn't commit us to running into a wall
            // or a collision with the previously moved friendly plane
            ArrayList<Move> potentialMoves = new ArrayList<Move>();
            for (Direction candidateDirection : p.getPossibleDirections()) {
                if (i==1 && myPlanes[0].simulateMove(moves[0]).getPosition().equals(myPlanes[1].simulateMove(new Move(candidateDirection,false,false)).getPosition())) {

                } else {                
                    Plane future = new Plane(arenaSize, 0, p.getDirection(), p.getPosition().add(candidateDirection.getAsPoint3D())); 
                    if (!dangerZone(future)) {
                                potentialMoves.add(new Move(candidateDirection, false, false));
                    }
                    future = new Plane(arenaSize, 0, candidateDirection, p.getPosition().add(candidateDirection.getAsPoint3D())); 
                    if (!dangerZone(future)) {
                            potentialMoves.add(new Move(candidateDirection, true, false));
                    }
                }
            }

            // everywhere our enemies might end up
            // including both directions they could be facing for each location
            ArrayList<Plane> futureEnemies = new ArrayList<Plane>();
            for (Plane e : enemyPlanes) {
                if (e.isAlive()) {
                    for (Direction candidateDirection : e.getPossibleDirections()) {
                        futureEnemies.add(new Plane(
                            arenaSize, 
                            e.getCoolDown(), 
                            candidateDirection, 
                            e.getPosition().add(candidateDirection.getAsPoint3D())
                            ));
                        // don't make a duplicate entry for forward moves
                        if (!candidateDirection.getAsPoint3D().equals(e.getDirection().getAsPoint3D())) {
                            futureEnemies.add(new Plane(
                                arenaSize, 
                                e.getCoolDown(), 
                                e.getDirection(), 
                                e.getPosition().add(candidateDirection.getAsPoint3D())
                                ));
                        }
                    }
                }
            }

            // a list of moves that are out of enemies' potential line of fire
            // also skipping potential collisions unless we are ahead on planes
            ArrayList<Move> safeMoves = new ArrayList<Move>();
            for (Move candidateMove : potentialMoves) {
                boolean safe = true;
                Point3D future = p.simulateMove(candidateMove).getPosition();
                for (Plane ec : futureEnemies) {
                    if (ec.getPosition().equals(future)) {
                        if (
                            (myPlanes[0].isAlive()?1:0) + (myPlanes[1].isAlive()?1:0)
                            <= 
                            (enemyPlanes[0].isAlive()?1:0) + (enemyPlanes[1].isAlive()?1:0)
                        ) {
                            safe = false;
                            break;
                        }
                    }
                    if (ec.isAlive() && ec.canShoot()) {
                        Point3D[] range = ec.getShootRange();
                        for (Point3D t : range) {
                            if (future.equals(t)) {
                                safe = false;
                                break;
                            }
                        }
                        if (safe == false) {
                            break;
                        }
                    }
                }
                if (safe == true) {
                    safeMoves.add(candidateMove);
                }
            }

            // a list of moves that let us attack a space an enemy might be in
            // ignore enemies committed to suicide vs a wall
            // TODO: don't shoot at friendly planes
            ArrayList<Move> attackMoves = new ArrayList<Move>();
            for (Move candidateMove : potentialMoves) {
                int attackCount = 0;
                Plane future = p.simulateMove(candidateMove);
                Point3D[] range = future.getShootRange();
                for (Plane ec : futureEnemies) {
                    for (Point3D t : range) {
                        if (ec.getPosition().equals(t)) {
                            if (!dangerZone(ec)) {
                                    attackMoves.add(new Move(candidateMove.direction, candidateMove.changeDirection, true));
                                    attackCount++;
                            }
                        }
                    }
                }
                if (attackCount > 0) {

                }
            }

            // find all attack moves that are also safe moves
            ArrayList<Move> safeAttackMoves = new ArrayList<Move>();
            for (Move safeCandidate : safeMoves) {
                for (Move attackCandidate : attackMoves) {
                    if (safeCandidate.direction == attackCandidate.direction) {
                        safeAttackMoves.add(attackCandidate);
                    }
                }
            }

            // choose the safe move that aims closest potential enemy positions
            int maxDistanceCubed = arenaSize*arenaSize*arenaSize*8;
            Move homingMove = null;
            int bestHomingMoveTotalDistancesCubed = maxDistanceCubed*1000;
            for (Move candidateMove : safeMoves) {
                int totalCandidateDistancesCubed = 0;
                for (Plane ec : futureEnemies) {
                    if (ec.isAlive()) {
                        int distThisEnemyCubed = maxDistanceCubed;
                        Point3D[] range = p.simulateMove(candidateMove).getShootRange();
                        for (Point3D t : range) {
                            int d1 = distanceCubed(t, ec.getPosition());
                            if (d1 < distThisEnemyCubed) {
                                distThisEnemyCubed = d1;
                            }
                        }
                        totalCandidateDistancesCubed += distThisEnemyCubed;
                    }
                }
                if (totalCandidateDistancesCubed < bestHomingMoveTotalDistancesCubed) {
                    bestHomingMoveTotalDistancesCubed = totalCandidateDistancesCubed;
                    homingMove = candidateMove;
                }
            }

            Random rng = new Random();
            // move to attack safely if possible
            // even if we can't shoot, this is good for chasing enemies
            if (safeAttackMoves.size() > 0) {
                moves[i] = safeAttackMoves.get(rng.nextInt(safeAttackMoves.size()));
                }
            // turn towards enemies if it's possible and safe
            // tests indicate value of this strategy varies significantly by opponent
            // useHoming changes based on outcome of early fights with[out] it
            // TODO: track enemy movement, aim for neighborhood
            else if (useHoming == true && homingMove != null) {
                moves[i] = homingMove;
                }
            // make random move, safe from attack
            else if (safeMoves.size() > 0) {
                moves[i] = safeMoves.get(rng.nextInt(safeMoves.size()));
                }
            // move to attack unsafely only if there are no safe moves
            else if (attackMoves.size() > 0 && p.canShoot()) {
                moves[i] = attackMoves.get(rng.nextInt(attackMoves.size()));
                }
            // make random move, safe from walls
            else if (potentialMoves.size() > 0) {
                moves[i] = potentialMoves.get(rng.nextInt(potentialMoves.size()));
                }
            // keep moving forward
            // this should never happen
            else {
                moves[i] = new Move(p.getDirection(), false, true);
                }
        }
        roundNum++;
        return moves;
    }

    @Override
    public void newFight(int fightsFought, int myScore, int enemyScore) {
        // try the homing strategy for 1/8 of the match
        // skip it for 1/8, then choose the winning option
        if (fightsFought == fightsPerMatch/8) {
            homingScore = myScore-enemyScore;
            useHoming = false;
        } else if (fightsFought == (fightsPerMatch/8)*2) {
            if (homingScore*2 > myScore-enemyScore) {
                useHoming = true;
            }
        }
        fightNum = fightsFought;
        roundNum = 0;
    }

    @Override
    public void newOpponent(int fights) {
        fightsPerMatch = fights;
    }
}

1
বর্তমানে প্রায় প্রতিটি সময় ভ্রিলিগিগকে মারধর করে। শত্রু-শট-এড়ানোর কোডে একটি বাগ সন্ধান করতে হবে।
স্পার

1
বাগ ঠিক করা। বর্তমান বিরোধীদের এখন 0 লোকসান।
স্পার

2
হ্রাস ড্র, উল্লেখযোগ্য অগ্রগতি নিয়ে কাজ করা হয়েছে। আমি আরও বেশি অগ্রগতি করতে পারার আগে স্মার্ট শত্রু বিমানের দরকার।
স্পার

1
অনিরাপদভাবে শুটিং করার আগে আমি নিরাপদ স্থানে যাওয়ার অগ্রাধিকার দেব
ক্রંચার

1
@ ক্র্যাঞ্চার আমার স্থানীয় অনুলিপিটিতে ইতিমধ্যে তা করছে এবং এটি বর্তমান বিরোধীদের বিরুদ্ধে কয়েক% পারফরম্যান্স উন্নত করে। এছাড়াও যখন আমি বিমানগুলি থেকে বেঁচে থাকি তখন সংঘর্ষগুলি এড়ানো আপডেট আসতে!
স্পার 17

18

ডগফাইট 3 ডি ভিজ্যুয়ালাইজার

আমি এই চ্যালেঞ্জের জন্য একটি ছোট, দ্রুত ভিজ্যুয়ালাইজার লিখেছি। কোড এবং জারের ফাইলগুলি আমার গিথুব রেপোতে রয়েছে : https://github.com/Hungary-Dude/DogfightVisualizer
এটি libGDX ( http://libgdx.com ) ব্যবহার করে তৈরি করা হয়েছে । এই মুহুর্তে ইউআই বেশ খারাপ, আমি এটিকে এক সাথে দ্রুত রেখেছি।

আমি কেবল গিট এবং গ্রেডল কীভাবে ব্যবহার করব তা শিখছি তাই দয়া করে যদি আমি কিছু ভুল করে থাকি তবে মন্তব্য করুন

চালান dist/dogfight.batবাdist/dogfight.sh ডামপ্ল্লেইনগুলি অ্যাকশনে দেখতে!

উত্স থেকে তৈরি করতে, আপনার আইডিইর জন্য গ্রেডল ( http://gradle.org ) এবং গ্রেডল একীকরণ প্রয়োজন, যদি আপনার কাছে এটি থাকে। তারপরে রেপো ক্লোন করে চালান gradlew desktop:run। আশা করি গ্রেডল প্রয়োজনীয় সমস্ত গ্রন্থাগার আমদানি করবে। মূল ক্লাসটি হ'লzove.koth.dogfight.desktop.DesktopLauncher

আমদানি না করে চলছে

যে কোনও বিমান শ্রেণীর ফাইলগুলিতে অনুলিপি করুন dist/। তারপরে, dist/desktop-1.0.jarএই আদেশটি দিয়ে চালান :

java -cp your-class-folder/;desktop-1.0.jar;Planes.jar zove.koth.dogfight.desktop.DesktopLauncher package.YourPlaneController1 package.YourPlaneController2 ...

প্লেন নিয়ন্ত্রকের উত্স আপডেট হওয়ার সাথে সাথে আমি আপডেট করব তবে নিজেকে আপডেট করতে আপনাকে কিছু কোড যুক্ত করতে হবে Planes.Controller । এ সম্পর্কিত তথ্যের জন্য গিথুব রিডমি দেখুন।

এখানে একটি স্ক্রিনশট: স্ক্রিনশট

আপনার যদি কোনও প্রশ্ন বা পরামর্শ থাকে তবে নীচে একটি মন্তব্য করুন!


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

আমি বিমানের অবস্থানের প্রতিনিধিত্বকারী পয়েন্ট 3 ডি নিয়েছি এবং তাদের দৃশ্যে সরানোর জন্য প্রতিটি স্থানাঙ্ক থেকে 6.5 বিয়োগ করেছি। ভালো কিছু plane.transform.setToTranslation(new Vector3(point3d.x-6.5f,point3d.y-6.5f,point3d.z-6.5f))কোন প্লেন সীমার বাইরে যেতে তাই আমার সন্দেহ কিছু অস্বাভাবিক হয় বলে মনে হচ্ছে
DankMemes

আহ অপেক্ষা করুন, আপনি উচ্চ অক্ষর হিসাবে y অক্ষ ব্যবহার করছেন? (বেশিরভাগ গেমগুলির মতো আমিও মনে করি) আমার সিস্টেমে জেড উচ্চতা উপস্থাপন করে, এটি যে খুব বেশি গুরুত্ব দেয় তা নয়, কারণ এটি প্রতিসাম্য
অতিবাহক

ওহহহহহ্ আমি পেয়েছি। দুঃখিত আমি আসলে আপনার কোডটি তেমনভাবে দেখিনি। আমি কেবল পয়েন্ট 3 ডি গুলি সরাসরি লিবিজিডিএক্স ভেক্টর 3 তে অনুবাদ করেছি। যাইহোক, আমি এক সপ্তাহ বা আরও কাল থেকে শুরু করব away আপনার কিছু দরকার হলে আমি এখানে না থাকলে দুঃখিত। আমি দূরে থাকায় চেক ইন করার চেষ্টা করব
ড্যাঙ্কমিমেস

12

EmoFockeWulf

সে ফিরে এসেছে. তিনি 224 বাইটে নিজেকে অনাহারে ফেলেছেন। কীভাবে সে এভাবে শেষ হয়েছিল সে জানে না।

package Planes;public class EmoFockeWulf extends PlaneControl{public EmoFockeWulf(int s, int r){super(s,r);}public Move[] act(){Move[] m=new Move[2];m[0]=new Move(myPlanes[0].getDirection(),false,false);m[1]=m[0];return m;}}

13
এটি এখন গুরুত্বের সাথে হাতছাড়া হচ্ছে। আমরা কীভাবে তাকে চিরকালের জন্য স্ট্যান্ডার্ড ফাঁক পোস্টে বিতাড়িত করব?
ব্যবহারকারী 80551

13
@ ব্যবহারকারী 80551 আমি নির্বিশেষে এটি খেলার একটি বৈধ শৈলী মনে করি। এটি নিষিদ্ধ করার কোনও কারণ নেই।
সেয়েরিয়া

3
তিনি তার চেয়ে 47 বাইট মোটা!
johnchen902

2
এর চেয়ে দ্রুত আত্মহত্যা করতে পারত সে। খুব কার্যকরভাবে ইমো নয়।
স্পার

2
@ স্পার হ্যাঁ, তবে তারপরে এটির বাইট গণনা আরও বেশি হবে এবং এটি সর্বদা না হারানোর বিড়ম্বনাটি হারাবে। : পি
সিজেফায়ার

10

Weeeeeeeeeeee - সাদা স্থান অপসারণের পরে 344 বাইট

দুর্দান্ত উপাদানগুলি করে আপনি লুপগুলি করছেন তবে হারাতে পারবেন না।

package Planes;
public class W extends PlaneControl{
    int i,c;
    int[] s={1,1,1,0,-1,-1,-1,0};
    public W(int a,int r){
        super(a,r);
    }
    public void newFight(int a,int b,int c){
        i=4;
    }
    public Move[] act(){
        Plane p=myPlanes[0];
        if(++i<6)
            c=p.getX()==0?1:-1;
        Move n=new Move(i<8?p.getDirection():new Direction(c*s[(i+2)%8],0,c*s[i%8]),0<1,i%2<1);
        Move[] m={n,n};
        return m;
    }
}

সম্পাদনা: স্পষ্টতই যখন আমার বিমানটি দল 2 হিসাবে শুরু হয়েছিল, তখনই তারা কেবল প্রাচীরের সাথে বিধ্বস্ত হয়েছিল। আমি মনে করি আমি এখন এটি স্থির করেছি। আশা রাখি,।


আপনার ফেরতের বিবৃতি আইনী নয়। জাভাতে, সমস্ত লাইনের সমস্ত বিষয়বস্তুকে নির্দিষ্ট করে রেখায় এমন অবজেক্টের অ্যারে তৈরি করতে আপনার new Type[]{item1, item2, ...}এই ক্ষেত্রে ব্যবহার করতে হবেreturn new Move[]{new Move(d,z,a),new Move(d,z,a^=z)};
ড্যাঙ্কমেস

আপনার যদি আইডিই ডাউনলোড না হয় তবে ব্রাউজি ডটকমের চেষ্টাও করুন । (এটি মোটেও শক্তিশালী নয় তবে এটি কাজ করে)
ড্যানকমেস

ধন্যবাদ, আমি যদি ভুলে গিয়েছিলাম তবে তা কাজ করে কিনা। উত্তরাধিকার এবং প্যাকেজটির সমস্ত কাজ করার জন্য আমি কেবল তার ক্লাসগুলি ডাউনলোড করতে চাই নি।
ছদ্মনাম

নতুন কোড দিয়ে আপনার প্লেনগুলি চালানোর পরে, এটি কেবল এস এবং এসই ফিরে আসছে এবং প্রতিবার 15 তম রাউন্ডে মারা যাচ্ছে। কোন ধারণা কেন?
ওভাররেেক্টর 15:54 এ

হুম ... না স্পষ্টতই আমি আমার পরিবর্তন নিয়ে গণ্ডগোল করেছি। এটি সত্যিই কাজ করবে আশা করেছিলাম .... সম্পাদনাটি পূর্বাবস্থায় ফিরে আসবে।
ছদ্মনাম

6

সরানো এবং অঙ্কুর বিমান

দেয়ালটি যখন প্রাচীরের কাছাকাছি থাকে এবং বাঁকানো হয় তখন সন্ধান করে দেয়ালগুলি এড়িয়ে যায়।

    package Planes;

public class MoveAndShootPlane extends PlaneControl {

    public MoveAndShootPlane(int arenaSize, int rounds) {
        super(arenaSize, rounds);
    }

    @Override
    public Move[] act() {
        Move[] moves = new Move[2];

        for (int i=0; i<2; i++) {
            if (!myPlanes[i].isAlive()) {
                moves[i] = new Move(new Direction("N"), false, false); // If we're dead we just return something, it doesn't matter anyway.
                continue;
            }
            // What direction am I going again?
            Direction currentDirection = myPlanes[i].getDirection();

            // Is my plane able to shoot?
            boolean canIShoot = myPlanes[i].canShoot();

            // if a wall is near me, turn around, otherwise continue along
            if (myPlanes[i].getDirection().getAsString().equals("N") && myPlanes[i].getDistanceFromWall('N') <= 2) {
                if (myPlanes[i].getDistanceFromWall('U') > myPlanes[i].getDistanceFromWall('D')) {
                    moves[i] = new Move(new Direction("NU"), true, canIShoot);
                } else {
                    moves[i] = new Move(new Direction("ND"), true, canIShoot);
                } 
            } else if (myPlanes[i].getDirection().getAsString().equals("S") && myPlanes[i].getDistanceFromWall('S') <= 2) {
                if (myPlanes[i].getDistanceFromWall('U') > myPlanes[i].getDistanceFromWall('D')) {
                    moves[i] = new Move(new Direction("SU"), true, canIShoot);
                } else {
                    moves[i] = new Move(new Direction("SD"), true, canIShoot);
                } 
            } else {
                if (myPlanes[i].getDirection().getAsString().equals("N") || myPlanes[i].getDirection().getAsString().equals("S")) {             
                    moves[i] = new Move(currentDirection, false, canIShoot);
                } else if (myPlanes[i].getDistanceFromWall('N') < myPlanes[i].getDistanceFromWall('S')) {
                    if (myPlanes[i].getDirection().getAsString().equals("NU")) {
                        moves[i] = new Move(new Direction("U"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("U")) {
                        moves[i] = new Move(new Direction("SU"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("SU")) {
                        moves[i] = new Move(new Direction("S"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("ND")) {
                        moves[i] = new Move(new Direction("D"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("D")) {
                        moves[i] = new Move(new Direction("SD"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("SD")) {
                        moves[i] = new Move(new Direction("S"), true, canIShoot);
                    }
                } else {
                    if (myPlanes[i].getDirection().getAsString().equals("SU")) {
                        moves[i] = new Move(new Direction("U"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("U")) {
                        moves[i] = new Move(new Direction("NU"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("NU")) {
                        moves[i] = new Move(new Direction("N"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("SD")) {
                        moves[i] = new Move(new Direction("D"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("D")) {
                        moves[i] = new Move(new Direction("ND"), true, canIShoot);
                    } else if (myPlanes[i].getDirection().getAsString().equals("ND")) {
                        moves[i] = new Move(new Direction("N"), true, canIShoot);
                    }
                }
            }
        }
        return moves;
    }

    @Override
    public void newFight(int fightsFought, int myScore, int enemyScore) {
        // Using information is for schmucks.
    }

    @Override
    public void newOpponent(int fights) {
        // What did I just say about information?
    }
}     

দাবি অস্বীকার: আমি মোটেই জাভা প্রোগ্রামার নই, সুতরাং আমি যদি কিছু ভুল করে থাকি তবে দয়া করে আমার জন্য এটি ঠিক করুন!


আমি এটি এখনও পরীক্ষা করে দেখিনি, তবে এটি কাজ করবে না, আপনি একবারে 180 ডিগ্রি ঘুরিয়ে দেওয়ার চেষ্টা করছেন। ইঙ্গিত হিসাবে, N-> NU-> U-> SU-> S কে N-> S এর স্থানে চেষ্টা করুন বা ছাদ মেঝে থেকে আরও কাছাকাছি থাকলে U কে ডি দ্বারা প্রতিস্থাপন করুন।
ওভাররেक्टर

@ প্রেমিক: আমি you may only change your angle by 45 degreesকিছুটা মিস করেছি ।
কাইল কানোজ

কোনও সমস্যা নেই, এটি সংশোধন করা খুব কঠিন হওয়া উচিত নয়।
ওভাররেੈਕਟਰ

আপনার সম্ভবত হ্যাশটেবলের পরিবর্তে হ্যাশম্যাপ <স্ট্রিং> ব্যবহার করা উচিত। অন্যথায়, new Direction(wayToGo.get(currentDirection))স্ট্রিংয়ে কাস্ট করা ভুলে যায় বলে কাজ করবে না। ওয়েডটোগো.পুটটি ক্ষেত্রের পরেও বৈধ নয়, এটি একটি ব্লক - ওয়েওটোগো.পুট (ব্লাহ); ব্লাহ; in বা কনস্ট্রাক্টরে রাখুন।
লুনা

7
আপাতত এটি দেয়ালে না উড়ানোর কারণে সমস্ত কিছু জিতেছে।
ওভাররেੈਕਟਰ

6

নাগরদোলা

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

package Planes;

public class Whirligig extends PlaneControl{

    public Whirligig(int arenaSize, int rounds) {
        super(arenaSize, rounds);
        cycle = -1;
    }

    int cycle;
    String[][] cycles = {
            {"E","EU","U","WU","W","WD","D","ED"},
            {"N","NU","U","SU","S","SD","D","ND"},
            {"S","SW","W","NW","N","NE","E","SE"},
            {"ED","D","WD","W","WU","U","EU","E"},
            {"ND","D","SD","S","SU","U","NU","N"},
            {"SE","E","NE","N","NW","W","SW","S"},
    };

    private Move act(int idx){
        Plane plane = myPlanes[idx];
        Move move = new Move(plane.getDirection(), true, plane.canShoot());
        if(!plane.isAlive())
            return new Move(new Direction("N"), false, false);

        if(cycle < 0){
            if(idx == 0 && (myPlanes[1].getZ() == 0 || myPlanes[1].getZ() == 13)){
                return move;
            }
            if(distanceToCenter(plane.getPosition()) > 2){
                move.direction = initialMove(plane);
            } else {
                cycle = (int)(Math.random()*3);
            }
        } else {
            move.direction = continueCycle(plane, cycle + (idx*3));
        }
        return move;
    }

    private Direction initialMove(Plane plane){
        if(plane.getDirection().getNSDir() > 0)
            return new Direction("SU");
        else
            return new Direction("ND");
    }

    private Direction continueCycle(Plane plane, int pathIndex){
        Direction current = plane.getDirection();
        String[] path = cycles[pathIndex];
        for(int i=0;i<path.length;i++)
            if(path[i].equals(current.getAsString()))
                return new Direction(path[(i+1)%path.length]);

        Direction[] possible = plane.getPossibleDirections();
        int step = (int)(Math.random()*path.length);
        for(int i=0;i<path.length;i++){
            for(int j=0;j<possible.length;j++){
                if(path[(i+step)%path.length].equals(possible[j].getAsString()))
                    return new Direction(path[(i+step)%path.length]);
            }
        }       
        return plane.getDirection();
    }

    private int distanceToCenter(Point3D pos){
        int x = (int)Math.abs(pos.x - 6.5); 
        int y = (int)Math.abs(pos.y - 6.5); 
        int z = (int)Math.abs(pos.z - 6.5);
        return Math.max(x, Math.max(y,z));
    }

    @Override
    public Move[] act() {
        Move[] moves = new Move[2];
        for(int i=0;i<2;i++){
            moves[i] = act(i);
        }
        return moves;
    }

    @Override
    public void newFight(int fought, int wins, int losses){
        cycle = -1;
    }

    @Override
    public void newOpponent(int fights){
        cycle = -1;
    }

}

4

DumbPlanes

ডাম্বপ্লেনগুলি দেয়ালগুলিতে উড়ে না যাওয়ার জন্য এত চেষ্টা করে তবে তারা এটি সম্পর্কে খুব স্মার্ট নয় এবং সাধারণত যেভাবেই দেয়ালটি আঘাত করে। তারা মাঝে মধ্যে গুলিও করে, যদি তারা জানত যে তারা কী গুলি করছে।

package Planes;

public class DumbPlanes extends PlaneControl {

    public DumbPlanes(int arenaSize, int rounds) {
        super(arenaSize, rounds);
    }

    @Override
    public Move[] act() {
        Move[] moves = new Move[2];
        for (int i=0; i<2; i++) {
            if (!myPlanes[i].isAlive()) {
                moves[i] = new Move(new Direction("N"), false, false); // If we're dead we just return something, it doesn't matter anyway.
                continue;
            }
            Direction[] possibleDirections = myPlanes[i].getPossibleDirections(); // Let's see where we can go.

            for (int j=0; j<possibleDirections.length*3; j++) {

                int random = (int) Math.floor((Math.random()*possibleDirections.length)); // We don't want to be predictable, so we pick a random direction out of the possible ones.

                if (myPlanes[i].getPosition().add(possibleDirections[random].getAsPoint3D()).isInArena(arenaSize)) { // We'll try not to fly directly into a wall.
                    moves[i] = new Move(possibleDirections[random], Math.random()>0.5, myPlanes[i].canShoot() && Math.random()>0.2);
                    continue; // I'm happy with this move for this plane.
                }

                // Uh oh.
                random = (int) Math.floor((Math.random()*possibleDirections.length));
                moves[i] = new Move(possibleDirections[random], Math.random()>0.5, myPlanes[i].canShoot() && Math.random()>0.2);
            }
        }

        return moves;
    }

    @Override
    public void newFight(int fightsFought, int myScore, int enemyScore) {
        // Using information is for schmucks.
    }

    @Override
    public void newOpponent(int fights) {
        // What did I just say about information?
    }
}

4

স্টারফক্স (ডব্লিউআইপি - এখনও কাজ করছে না):

তিনি আসলে উপলব্ধ সমস্ত পদক্ষেপ ব্যবহার করে না। তবে তিনি শত্রুদের গুলি করার চেষ্টা করেছেন এবং দেওয়ালের মধ্যে না পড়ে।

package Planes;

import java.util.ArrayList;
import java.util.function.Predicate;

public class Starfox extends PlaneControl
{

    public Starfox(int arenaSize, int rounds)
    {
        super(arenaSize, rounds);
    }

    private ArrayList<Point3D> dangerousPositions;
    private ArrayList<Point3D> riskyPositions;

    @Override
    public Move[] act()
    {
        dangerousPositions = new ArrayList<>();
        riskyPositions = new ArrayList<>();

        // add corners as places to be avoided
        dangerousPositions.add(new Point3D(0,0,0));
        dangerousPositions.add(new Point3D(0,0,arenaSize-1));
        dangerousPositions.add(new Point3D(0,arenaSize-1,0));
        dangerousPositions.add(new Point3D(0,arenaSize-1,arenaSize-1));
        dangerousPositions.add(new Point3D(arenaSize-1,0,0));
        dangerousPositions.add(new Point3D(arenaSize-1,0,arenaSize-1));
        dangerousPositions.add(new Point3D(arenaSize-1,arenaSize-1,0));
        dangerousPositions.add(new Point3D(arenaSize-1,arenaSize-1,arenaSize-1));


        for (Plane p : super.enemyPlanes)
        {
            for (Direction d : p.getPossibleDirections())
            {
                Point3D potentialPosition = new Point3D(p.getX(), p.getY(), p.getZ()).add(d.getAsPoint3D());
                if (potentialPosition.isInArena(arenaSize))
                {
                    riskyPositions.add(potentialPosition);
                    if (p.canShoot())
                    {
                        for (Point3D range : p.getShootRange())
                        {
                            riskyPositions.add(range.add(potentialPosition));
                        }
                    }
                }
            }
        }

        ArrayList<Move> moves = new ArrayList<>();

        for (Plane p : myPlanes)
        {
            if (p.isAlive())
            {
                ArrayList<Direction> potentialDirections = new ArrayList<>();

                for (Direction d : p.getPossibleDirections())
                {
                    Point3D potentialPosition = new Point3D(p.getX(), p.getY(), p.getZ()).add(d.getAsPoint3D());
                    if (potentialPosition.isInArena(arenaSize))
                    {
                        potentialDirections.add(d);
                    }
                }

                // remove dangerous positions from flight plan
                potentialDirections.removeIf(new Predicate<Direction>()
                {
                    @Override
                    public boolean test(Direction test)
                    {
                        boolean result = false;
                        for (Point3D compare : dangerousPositions)
                        {
                            if (p.getPosition().add(test.getAsPoint3D()).equals(compare))
                            {
                                result = true;
                            }
                        }
                        return result && potentialDirections.size() > 0;
                    }
                });

                // remove positions with no future from flight plan

                potentialDirections.removeIf(new Predicate<Direction>()
                {
                    @Override
                    public boolean test(Direction test)
                    {
                        boolean hasFuture = false;
                        for (Direction compare : p.getPossibleDirections())
                        {
                            Plane future = new Plane(arenaSize, 0, compare, p.getPosition().add(compare.getAsPoint3D()));
                            if (future!=null && future.getDirection()!=null) {
                                for (Direction d : future.getPossibleDirections())
                                {
                                    if (future.getPosition().add(d.getAsPoint3D()).isInArena(arenaSize))
                                    {
                                        hasFuture = true;
                                        break;
                                    }
                                }
                            }
                        }
                        return !hasFuture;
                    }
                });

                // remove risky positions from flight plan
                potentialDirections.removeIf(new Predicate<Direction>()
                {
                    @Override
                    public boolean test(Direction test)
                    {
                        boolean result = false;
                        for (Point3D compare : riskyPositions)
                        {
                            if (p.getPosition().add(test.getAsPoint3D()).equals(compare))
                            {
                                result = true;
                            }
                        }
                        return result && potentialDirections.size() > 0;
                    }
                });

                // check for targets
                Direction best = null;
                if (p.canShoot())
                {
                    int potentialHits = 0;
                    for (Direction d : potentialDirections)
                    {
                        Plane future = new Plane(arenaSize, 0, d, p.getPosition().add(d.getAsPoint3D()));
                        for (Point3D t : future.getShootRange())
                        {
                            int targets = 0;
                            for (Plane e : super.enemyPlanes)
                            {
                                for (Direction s : e.getPossibleDirections())
                                {
                                    Plane target = new Plane(arenaSize, 0, s, e.getPosition().add(s.getAsPoint3D()));
                                    if (target.getPosition().equals(t))
                                    {
                                        targets++;
                                    }

                                }
                            }
                            if (targets > potentialHits)
                            {
                                best = d;
                                potentialHits = targets;
                            }
                        }
                    }
                }

                if (best == null)
                {
                    if (potentialDirections.size() > 0) {
                        best = potentialDirections.get((int) Math.floor(Math.random() * potentialDirections.size()));
                    } else {
                        best = new Direction("N");
                    }
                }

                moves.add(new Move(best, true, false));
                dangerousPositions.add(p.getPosition().add(best.getAsPoint3D()));

            }
            else
            {
                // this plane is dead, not much to do but go hide in corner
                moves.add(new Move(new Direction("N"), false, false));

            }
        }

        Move[] movesArr = {moves.get(0), moves.get(1)};
        return movesArr;
    }

    @Override
    public void newFight(int fightsFought, int myScore, int enemyScore)
    {
        // Using information is for schmucks.
    }

    @Override
    public void newOpponent(int fights)
    {
        // What did I just say about information?
    }
}

7
কিন্তু এটি কি ব্যারেল রোল করতে পারে?
এর্তে সিডোহাল

1
আমি একটি ব্যতিক্রম পাচ্ছি, এখানে স্ট্যাক ট্রেস রয়েছে: "মূল" java.lang. থ্রেডে ব্যতিক্রম প্লেনস.স্টারফক্স $ 2. টেস্ট (স্টারফক্স.জভা.৯৯) এ প্লেনস.স্টারফক্স $ ২.০test (স্টারফক্স.জভা অনুচ্ছেদ) ) java.util.ArrayList.removeIf (অজানা উত্স) প্লেনস.স্টারফক্স.এ্যাক্ট (স্টারফক্স.জভা: ৯৯০) প্লেনস.কন্ট্রোলআরফাইট (কন্ট্রোলারআরজাভা ১৪:১১) এ প্লেনস.কন্ট্রোলআরমাচআপ (কন্ট্রোলারআরভা:) 85) Planes.Controller.main এ (কন্ট্রোল.আরজাভা ৩:35) আমাকে প্যাকেজ প্লেন যুক্ত করতে হয়েছিল, অন্যথায় এটি সংকলন করবে না, সম্ভবত এটির সাথে কিছু করার ছিল।
ওভাররেেক্টর

আমি এটি চালাতে পেরেছি তবে এটি প্রত্যাশার মতো পারফরম্যান্স করছে না, আমি মনে করি সমস্যাটি সম্ভবত সবচেয়ে ভাল হয়ে যায় often
ওভাররেেক্টর

দেখে মনে হচ্ছে স্টারফক্স এটিকে না গিয়ে শত্রুদের আগুনে ফেলেছে, আপনি এখানে
ওভাররেੈਕਟਰ

3

DangerZoner

  • পাইথনে লিখিত এবং স্পার দ্বারা রচিত জাভা কোড র‌্যাপারের সাথে ইন্টারফেস।

  • খাঁটি পাইথনে এর সমস্ত গণিত রয়েছে এবং এটি সম্পূর্ণরূপে নিরবচ্ছিন্ন। কিছুটা ধীর।

  • উচ্চতর কনফিগার এবং এক্সটেনসিবল।

  • অতীত জমা দেওয়ার বিরুদ্ধে খুব ভাল করে। জেতা বিপক্ষে Crossfireবা হারিয়েছে তাদের জন্য ২: ১ টি লড়াই PredictAndAvoidজিতেছে এবং অন্যান্য প্রতিযোগীদের বিরুদ্ধে সমস্ত লড়াইয়ের 98 +% জিতেছে ।

এর নিজস্ব alচ্ছিক ভিজ্যুয়ালাইজেশন সরঞ্জাম অন্তর্ভুক্ত:

যুদ্ধ CrossfirePredictAndAvoidপার্শ্ববর্তী ভলিউমে ভিজ্যুয়ালাইজড অ্যাডমোনাস বিপদ অঞ্চল রেটিং সহ / ,

চারটি প্লেনের চারপাশে রঙিন ভক্সেল গ্রিড মোর্ফিং সহ দুটি রাউন্ডে ডগফাইটিংয়ের ভিডিও।

  • nipy_spectralথেকে কলারম্যাপ ব্যবহার করে ভিজ্যুয়ালাইজড matplotlib। আরও বিপজ্জনক স্থানাঙ্কগুলি ইলেক্ট্রোম্যাগনেটিক বর্ণালীতে লাল / সাদা রঙের কাছাকাছি রং ব্যবহার করে রেন্ডার করা হয় এবং বড় বিন্দু দিয়ে আঁকা হয়।

  • বিপদ: নীল <সবুজ <হলুদ <লাল <হালকা ধূসর

কর্মক্ষমতা:

লিডারবোর্ডে আটটি শীর্ষ অন্যান্য অ্যালগোরিদম সহ 1000 টি রাউন্ড:

SCORE: DumbPlanes: 0 Dangerzoner: 1000
SCORE: Crossfire: 132 Dangerzoner: 367
SCORE: PredictAndAvoid: 165 Dangerzoner: 465
SCORE: Wee: 0 Dangerzoner: 1000
SCORE: Whirligig: 0 Dangerzoner: 989
SCORE: MoveAndShootPlane: 0 Dangerzoner: 1000
SCORE: Starfox: 4 Dangerzoner: 984
SCORE: DumbPy: 0 Dangerzoner: 1000
SCORES:

DumbPlanes: 2 points.
Crossfire: 12 points.
PredictAndAvoid: 14 points.
Wee: 10 points.
Whirligig: 8 points.
MoveAndShootPlane: 6 points.
Starfox: 4 points.
DumbPy: 0 points.
Dangerzoner: 16 points.


THE OVERALL WINNER(S): Dangerzoner
With 16 points.

কোড:

#!/usr/bin/env python3
"""
DangerZoner

Each turn:
    1) Make a list of all possible locations to move to, explicitly excluding suicidal positions that will collide with the walls, an ally, or an ally's bullet.
    2) Rate each possible location using heuristics that estimate the approximate danger in that zone, accounting for the following factors:
        -Proximity to walls. (Manoeuvring constrictions and risk of collision.)
        -Proximity to fronts of planes. (Risk of mid-air collisions.)
        -High distance from enemy planes. (Risk of enemies easily turning to shoot.)
        -Intersection with all enemy attack vectors. (Explicit safety on the next round.)
        -Proximity to enemy forward vectors. (Approximate probability of being targeted in upcoming rounds.)
    3) If certain respective thresholds are met in the possible moves' danger ratings, then do the following if possible:
        -Take a potshot at a random position that an enemy might move to next turn (but never shoot an ally).
        -Take a potshot at an extrapolated position that an enemy will likely move to next turn if they keep up their current rate of turn (but never shoot an ally).
        -Turn to pursue the closest enemy.
        -Move randomly to confound enemy predictive mechanisms. (Disabled since implementing explicit enemy attack vectors in danger zone calculation.)
    4) If none of those thresholds are met, then choose the move rated as least dangerous.
"""

import math, random, functools, sys

#import NGrids
NGrids = lambda: None
class NSpace(object):
    """Object for representing an n-dimensional space parameterized by a list of extents in each dimension."""
    def __init__(self, dimensions):
        self.dimensions = tuple(dimensions)
    def check_coordshape(self, coord):
        return len(coord) == len(self.dimensions)
    def enforce_coordshape(self, coord):
        if not self.check_coordshape(coord):
            raise ValueError(f"Attempted to access {len(coord)}-coordinate point from {len(self.dimensions)}-coordinate space: {coord}")
    def check_coordrange(self, coord):
        return all((0 <= c <= b) for c, b in zip(coord, self.dimensions))
    def enforce_coordrange(self, coord):
        if not self.check_coordrange(coord):
            raise ValueError(f"Attempted to access coordinate point out of range of {'x'.join(str(d) for d in self.dimensions)} space: {coord}")
    def check_coordtype(self, coord):
        return True
    def enforce_coordtype(self, coord):
        if not self.check_coordtype(coord):
            raise TypeError(f"Attempted to access grid point with invalid coordinates for {type(self).__name__}(): {coord}")
    def enforce_coord(self, coord):
        for f in (self.enforce_coordshape, self.enforce_coordrange, self.enforce_coordtype):
            f(coord)
    def coords_grid(self, step=None):
        if step is None:
            step = tuple(1 for i in self.dimensions)
        self.enforce_coord(step)
        counts = [math.ceil(d/s) for d, s in zip(self.dimensions, step)]
        intervals = [1]
        for c in counts:
            intervals.append(intervals[-1]*c)
        for i in range(intervals[-1]):
            yield tuple((i//l)*s % (c*s) for s, l, c in zip(step, intervals, counts))
NGrids.NSpace = NSpace

def Pythagorean(*coords):
    return math.sqrt(sum(c**2 for c in coords))

class Plane(object):
    """Object for representing a single dogfighting plane."""
    def __init__(self, alive, coord, vec, cooldown=None, name=None):
        self.alive = alive
        self.set_alive(alive)
        self.coord = coord
        self.set_coord(coord)
        self.vec = vec
        self.set_vec(vec)
        self.cooldown = cooldown
        self.set_cooldown(cooldown)
        self.name = name
    def set_alive(self, alive):
        self.lastalive = self.alive
        self.alive = alive
    def set_coord(self, coord):
        self.lastcoord = self.coord
        self.coord = coord
    def set_vec(self, vec):
        self.lastvec = self.vec
        self.vec = vec
    def set_cooldown(self, cooldown):
        self.lastcooldown = self.cooldown
        self.cooldown = cooldown
    def update(self, alive=None, coord=None, vec=None, cooldown=None):
        if alive is not None:
            self.set_alive(alive)
        if coord is not None:
            self.set_coord(coord)
        if vec is not None:
            self.set_vec(vec)
        if cooldown is not None:
            self.set_cooldown(cooldown)
    def get_legalvecs(self):
        return getNeighbouringVecs(self.vec)
    def get_legalcoords(self):
        return {tuple(self.coord[i]+v for i, v in enumerate(vec)) for vec in self.get_legalvecs()}
    def get_legalfutures(self):
        return (lambda r: r.union((c, self.vec) for c, v in r))({(vecAdd(self.coord, vec),vec) for vec in self.get_legalvecs()})

class DangerZones(NGrids.NSpace):
    """Arena object for representing an n-dimensional volume with both enemy and allied planes in it and estimating the approximate safety/danger of positions within it. """
    def __init__(self, dimensions=(13,13,13), walldanger=18.0, walldistance=3.5, wallexpo=2.0, walluniformity=5.0, planedanger=8.5, planeexpo=8.0, planeoffset=1.5, planedistance=15.0, planedistancedanger=2.0, planedistanceexpo=1.5, firedanger=9.0, collisiondanger=10.0, collisiondirectionality=0.6, collisiondistance=2.5, collisionexpo=0.2):
        NGrids.NSpace.__init__(self, dimensions)
        self.walldanger = walldanger
        self.walldistance = walldistance
        self.wallexpo = wallexpo
        self.walluniformity = walluniformity
        self.planedanger = planedanger
        self.planeexpo = planeexpo
        self.planeoffset = planeoffset
        self.planedistance = planedistance
        self.planedistancedanger = planedistancedanger
        self.planedistanceexpo = planedistanceexpo
        self.firedanger = firedanger
        self.collisiondanger = collisiondanger
        self.collisiondirectionality = collisiondirectionality
        self.collisiondistance = collisiondistance
        self.collisionexpo = collisionexpo
        self.set_planes()
        self.set_allies()
        self.clear_expectedallies()
    def filteractiveplanes(self, planes=None):
        if planes is None:
            planes = self.planes
        return (p for p in planes if all((p.alive, p.coord, p.vec)))
    def rate_walldanger(self, coord):
        self.enforce_coordshape(coord)
        return (lambda d: (max(d)*self.walluniformity+sum(d))/(self.walluniformity+1))((1-min(1, (self.dimensions[i]/2-abs(v-self.dimensions[i]/2))/self.walldistance)) ** self.wallexpo * self.walldanger for i, v in enumerate(coord))
    def rate_planedanger(self, coord, planecoord, planevec):
        for v in (planecoord, planevec, coord):
            self.enforce_coordshape(v)
        return max(0, (1 - vecAngle(planevec, vecSub(coord, vecSub(planecoord, vecMult(planevec, (self.planeoffset,)*len(self.dimensions)))) ) / math.pi)) ** self.planeexpo * self.planedanger
        offsetvec = convertVecTrinary(planevec, length=self.planeoffset)
        relcoord = [v-(planecoord[i]-offsetvec[i]) for i, v in enumerate(coord)]
        nrelcoord = (lambda m: [(v/m if m else 0) for v in relcoord])(Pythagorean(*relcoord))
        planevec = (lambda m: [(v/m if m else 0) for v in planevec])(Pythagorean(*planevec))
        return max(0, sum(d*p for d, p in zip(planevec, nrelcoord))+2)/2 ** self.planeexpo * self.planedanger + min(1, Pythagorean(*relcoord)/self.planedistance) ** self.planedistanceexpo * self.planedistancedanger
    def rate_planedistancedanger(self, coord, planecoord, planevec):
        return Pythagorean(*vecSub(planecoord, coord))/self.planedistance ** self.planedistanceexpo * self.planedistancedanger
    def rate_firedanger(self, coord, plane):
        return (min(vecAngle(vecSub(coord, c), v) for c, v in plane.get_legalfutures()) < 0.05) * self.firedanger
    def rate_collisiondanger(self, coord, planecoord, planevec):
        if coord == planecoord:
            return self.collisiondanger
        offsetvec = tuple(p-c for p,c in zip(planecoord, coord))
        return max(0, vecAngle(planevec, offsetvec)/math.pi)**self.collisiondirectionality * max(0, 1-Pythagorean(*offsetvec)/self.collisiondistance)**self.collisionexpo*self.collisiondanger
    def set_planes(self, *planes):
        self.planes = planes
    def set_allies(self, *allies):
        self.allies = allies
    def rate_planesdanger(self, coord, planes=None):
        if planes is None:
            planes = {*self.planes}
        return max((0, *(self.rate_planedanger(coord, planecoord=p.coord, planevec=p.vec) for p in self.filteractiveplanes(planes))))
    def rate_planedistancesdanger(self, coord, planes=None):
        if planes is None:
            planes = {*self.planes}
        return max((0, *(self.rate_planedistancedanger(coord, planecoord=p.coord, planevec=p.vec) for p in self.filteractiveplanes(planes))))
    def rate_firesdanger(self, coord, planes=None):
        if planes is None:
            planes = {*self.planes}
        return sum(self.rate_firedanger(coord, p) for p in self.filteractiveplanes(planes))
    def rate_collisionsdanger(self, coord, pself=None, planes=None):
        if planes is None:
            planes = {*self.planes, *self.allies}
        return max((0, *(self.rate_collisiondanger(coord , planecoord=p.coord, planevec=p.vec) for p in self.filteractiveplanes(planes) if p is not pself)))
    def rate_sumdanger(self, coord, pself=None, planes=None):
        return max((self.rate_walldanger(coord), self.rate_planesdanger(coord, planes=planes), self.rate_planedistancesdanger(coord, planes=planes), self.rate_firesdanger(coord, planes=planes), self.rate_collisionsdanger(coord, pself=pself, planes=planes)))
    def get_expectedallies(self):
        return {*self.expectedallies}
    def clear_expectedallies(self):
        self.expectedallies = set()
    def add_expectedallies(self, *coords):
        self.expectedallies.update(coords)
    def get_expectedshots(self):
        return {*self.expectedshots}
    def clear_expectedshots(self):
        self.expectedshots = set()
    def add_expectedshots(self, *rays):
        self.expectedshots.update(rays)
    def tickturn(self):
        self.clear_expectedallies()
        self.clear_expectedshots()

def stringException(exception):
    import traceback
    return ''.join(traceback.format_exception(type(exception), exception, exception.__traceback__))

try:
    import matplotlib.pyplot, matplotlib.cm, mpl_toolkits.mplot3d, time
    class PlottingDangerZones(DangerZones):
        """Arena object for calculating danger ratings and rendering 3D visualizations of the arena state and contents to both files and an interactive display on each turn."""
        plotparams = {'dangersize': 80, 'dangersizebase': 0.2, 'dangersizeexpo': 2.0, 'dangeralpha': 0.2, 'dangerres': 1, 'dangervrange': (0, 10), 'dangercmap': matplotlib.cm.nipy_spectral, 'dangermarker': 'o', 'allymarker': 's', 'enemymarker': 'D', 'vectormarker': 'x', 'planesize': 60, 'vectorsize': 50, 'planecolour': 'black', 'deathmarker': '*', 'deathsize': 700, 'deathcolours': ('darkorange', 'red'), 'deathalpha': 0.65, 'shotlength': 4, 'shotcolour': 'darkviolet', 'shotstyle': 'dashed'}
        enabledplots = ('enemies', 'allies', 'vectors', 'danger', 'deaths', 'shots', 'names')
        def __init__(self, dimensions=(13,13,13), plotparams=None, plotautoturn=0, plotsavedir=None, enabledplots=None, disabledplots=None, tickwait=0.0, plotcycle=0.001, **kwargs):
            DangerZones.__init__(self, dimensions, **kwargs)
            self.figure = None
            self.axes = None
            self.frame = None
            self.plotobjs = {}
            self.plotshown = False
            if plotparams:
                self.set_plotparams(plotparams)
            self.plotautoturn = plotautoturn
            self.plotsavedir = plotsavedir
            if enabledplots:
                self.enabledplots = tuple(enabledplots)
            if disabledplots:
                self.enabledplots = tuple(m for m in self.enabledplots if m not in disabledplots)
            self.tickwait = tickwait
            self.plotcycle = plotcycle
            self.lasttick = time.time()
        def set_plotparams(self, plotparams):
            self.plotparams = {**self.plotparams, **plotparams}
        def prepare_plotaxes(self, figure=None, clear=True):
            if self.figure is None and figure is None:
                self.figure = matplotlib.pyplot.figure()
                self.frame = 0
            if self.axes is None:
                self.axes = self.figure.add_subplot(projection='3d')
            elif clear:
                self.axes.clear()
            for d, h in zip((self.axes.set_xlim, self.axes.set_ylim, self.axes.set_zlim), self.dimensions):
                d(0, h)
            return (self.figure, self.axes)
        def plotter(kind):
            def plotterd(funct):
                def plott(self):
                    kws = dict(getattr(self, funct.__name__.replace('plot_', 'plotparams_'))())
                    if '*args' in kws:
                        args = tuple(kws.pop('*args'))
                    else:
                        args = tuple()
                    if False and funct.__name__ in self.plotobjs:
                        self.plotobjs[funct.__name__].set(**kws)
                    else:
                        self.plotobjs[funct.__name__] = getattr(self.axes, kind)(*args, **kws)
                return plott
            return plotterd
        def plotparams_enemies(self):
            r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['enemymarker'], 's': self.plotparams['planesize'], 'c': self.plotparams['planecolour']}
            planes = tuple(self.filteractiveplanes(self.planes))
            if planes:
                r['xs'], r['ys'], r['zs'] = zip(*(p.coord for p in planes))
            return r
        def plotparams_allies(self):
            r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['allymarker'], 's': self.plotparams['planesize'], 'c': self.plotparams['planecolour']}
            planes = tuple(self.filteractiveplanes(self.allies))
            if planes:
                r['xs'], r['ys'], r['zs'] = zip(*(p.coord for p in planes))
            return r
        def plotparams_vectors(self):
            r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['vectormarker'], 's': self.plotparams['vectorsize'], 'c': self.plotparams['planecolour']}
            planes = tuple(self.filteractiveplanes(self.allies+self.planes))
            if planes:
                r['xs'], r['ys'], r['zs'] = zip(*(vecAdd(p.coord, p.vec) for p in planes))
            return r
        def plotparams_danger(self):
            r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['dangermarker'], 'cmap': self.plotparams['dangercmap'], 'alpha': self.plotparams['dangeralpha']}
            coords = tuple(self.coords_grid((self.plotparams['dangerres'],)*len(self.dimensions)))
            r['xs'], r['ys'], r['zs'] = zip(*coords)
            r['c'] = tuple(self.rate_sumdanger(c) for c in coords)
            m = max(r['c'])
            r['s'] = tuple((d/m)**self.plotparams['dangersizeexpo']*self.plotparams['dangersize']+self.plotparams['dangersizebase'] for d in r['c'])
            if self.plotparams['dangervrange']:
                r['vmin'], r['vmax'] = self.plotparams['dangervrange']
            return r
        def plotparams_deaths(self):
            r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['deathmarker'], 's': self.plotparams['deathsize'], 'c': self.plotparams['deathcolours'][0], 'linewidths': self.plotparams['deathsize']/180, 'edgecolors': self.plotparams['deathcolours'][1], 'alpha': self.plotparams['deathalpha']}
            deaths = tuple(p.lastcoord for p in self.planes+self.allies if p.lastalive and not p.alive)
            if deaths:
                r['xs'], r['ys'], r['zs'] = zip(*deaths)
            return r
        def plotparams_shots(self):
            r = {'length': self.plotparams['shotlength'], 'linestyles': self.plotparams['shotstyle'], 'color': self.plotparams['shotcolour'], 'arrow_length_ratio': 0.0, '*args': []}
            planes = tuple(p for p in self.filteractiveplanes(self.allies+self.planes) if not (p.lastcooldown is None or p.cooldown is None) and (p.cooldown > p.lastcooldown))
            if planes:
                for s in zip(*(p.coord for p in planes)):
                    r['*args'].append(s)
                for s in zip(*(p.vec for p in planes)):
                    r['*args'].append(s)
            else:
                for i in range(6):
                    r['*args'].append(tuple())
            return r
        @plotter('scatter')
        def plot_enemies(self):
            pass
        @plotter('scatter')
        def plot_allies(self):
            pass
        @plotter('scatter')
        def plot_vectors(self):
            pass
        @plotter('scatter')
        def plot_danger(self):
            pass
        @plotter('scatter')
        def plot_deaths(self):
            pass
        @plotter('quiver')
        def plot_shots(self):
            pass
        def plot_names(self):
            if 'plot_names' in self.plotobjs:
                pass
            self.plotobjs['plot_names'] = [self.axes.text(*p.coord, s=f"{p.name}") for i, p in enumerate(self.filteractiveplanes(self.allies+self.planes))]
        def plotall(self):
            for m in self.enabledplots:
                getattr(self, f'plot_{m}')()
        def updateallplots(self):
            self.prepare_plotaxes()
            self.plotall()
            if self.plotautoturn:
                self.axes.view_init(30, -60+self.frame*self.plotautoturn)
            matplotlib.pyplot.draw()
            if self.plotsavedir:
                import os
                os.makedirs(self.plotsavedir, exist_ok=True)
                self.figure.savefig(os.path.join(self.plotsavedir, f'{self.frame}.png'))
            self.frame += 1
            if not self.plotshown:
                matplotlib.pyplot.ion()
                matplotlib.pyplot.show()#block=False)
                self.plotshown = True
        def tickturn(self):
            DangerZones.tickturn(self)
            self.updateallplots()
            matplotlib.pyplot.pause(max(self.plotcycle, self.lasttick+self.tickwait-time.time()))
            self.lasttick = time.time()
except Exception as e:
    print(f"Could not define matplotlib rendering dangerzone handler:\n{stringException(e)}", file=sys.stderr)


def vecEquals(vec1, vec2):
    return tuple(vec1) == tuple(vec2)

def vecAdd(*vecs):
    return tuple(sum(p) for p in zip(*vecs))

def vecSub(vec1, vec2):
    return tuple(a-b for a, b in zip(vec1, vec2))

def vecMult(*vecs):
    return tuple(functools.reduce(lambda a, b: a*b, p) for p in zip(*vecs))

def vecDiv(vec1, vec2):
    return tuple(a-b for a, b in zip(vec1, vec2))

def vecDotProduct(*vecs):
    return sum(vecMult(*vecs))
    #return sum(d*p for d, p in zip(vec1, vec2))

def vecAngle(vec1, vec2):
    try:
        if all(c == 0 for c in vec1) or all(c == 0 for c in vec2):
            return math.nan
        return math.acos(max(-1, min(1, vecDotProduct(vec1, vec2)/Pythagorean(*vec1)/Pythagorean(*vec2))))
    except Exception as e:
        raise ValueError(f"{e!s}: {vec1} {vec2}")

def convertVecTrinary(vec, length=1):
    return tuple((max(-length, min(length, v*math.inf)) if v else v) for v in vec)

def getNeighbouringVecs(vec):
    vec = convertVecTrinary(vec, length=1)
    return {ve for ve in (tuple(v+(i//3**n%3-1) for n, v in enumerate(vec)) for i in range(3**len(vec))) if all(v in (-1,0,1) for v in ve) and any(v and v==vec[i] for i, v in enumerate(ve))}

def getVecRotation(vec1, vec2):
    #Just do a cross product/perpendicular to tangential plane/normal?
    pass

def applyVecRotation(vec, rotation):
    pass

class DangerZoner(Plane):
    """Dogfighting plane control object."""
    def __init__(self, arena, snipechance=0.60, snipechoices=3, firesafety=7.5, chasesafety=5.0, jinkdanger=math.inf, jink=0, name=None):
        Plane.__init__(self, True, None, None)
        self.arena = arena
        self.lookahead = 1
        self.snipechance = snipechance
        self.snipechoices = snipechoices
        self.firesafety = firesafety
        self.chasesafety = chasesafety
        self.jinkdanger = jinkdanger
        self.jink = jink
        self.vec = None
        self.name = name
    def get_enemies(self):
        return (p for p in self.arena.filteractiveplanes(self.arena.planes))
    def get_vecsuicidal(self, vec, coord=None, steps=5):
        if coord is None:
            coord = self.coord
        if all(3 < c < self.arena.dimensions[i]-3 for i, c in enumerate(coord)):
            return False
        if not all(0 < c < self.arena.dimensions[i] for i, c in enumerate(coord)):
            return True
        elif steps >= 0:
            return all(self.get_vecsuicidal(v, coord=vecAdd(coord, vec), steps=steps-1) for v in getNeighbouringVecs(vec))
        return False
    def get_sanevecs(self):
        legalvecs = self.get_legalvecs()
        s = {vec for vec in legalvecs if vecAdd(self.coord, vec) not in self.arena.get_expectedallies() and not any(vecAngle(vecSub(vecAdd(self.coord, vec), sc), sv) < 0.05 for sc, sv in self.arena.get_expectedshots()) and not self.get_vecsuicidal(vec, coord=vecAdd(self.coord, vec))}
        if not s:
            return legalvecs
            raise Exception()
        return s
    def rate_vec(self, vec, lookahead=None):
        if lookahead is None:
            lookahead = self.lookahead
        return self.arena.rate_sumdanger(tuple(c+v*lookahead for v, c in zip(vec, self.coord)), pself=self)
    def get_validshots(self, snipe=True):
        if snipe and random.random() < self.snipechance:
            enemypossibilities = set.union(*({vecAdd(p.coord, p.vec)} if not p.lastvec or vecEquals(p.vec, p.lastvec) else {vecAdd(p.coord, ve) for ve in sorted(p.get_legalvecs(), key=lambda v: -vecAngle(v, p.lastvec))[:self.snipechoices]} for p in self.get_enemies()))
        else:
            enemypossibilities = set().union(*(p.get_legalcoords() for p in self.get_enemies()))
        validshots = []
        if self.cooldown:
            return validshots
        for vec in self.get_sanevecs():
            coord = tuple(c + v for c, v in zip(self.coord, vec))
            if any(vecAngle(tuple(n-v for n, v in zip(t, self.coord)), self.vec) < 0.1 for t in enemypossibilities if t != self.coord) and not any(vecAngle(vecSub(a, coord), self.vec) < 0.05 for a in self.arena.get_expectedallies()):
                validshots.append({'vec': vec, 'turn': False, 'fire': True})
            if any(vecAngle(tuple(n-v for n, v in zip(t, self.coord)), vec) < 0.1 for t in enemypossibilities if t != self.coord) and not any(vecAngle(vecSub(a, coord), vec) < 0.05 for a in self.arena.get_expectedallies()):
                validshots.append({'vec': vec, 'turn': True, 'fire': True})
        if snipe and not validshots:
            validshots = self.get_validshots(snipe=False)
        return validshots
    def get_chase(self):
        enemydirs = {vecSub(vecAdd(p.coord, p.vec), self.coord) for p in self.get_enemies()}
        paths = sorted(self.get_sanevecs(), key=lambda vec: min([vecAngle(vec, e) for e in enemydirs if not all(v == 0 for v in e)]+[math.inf]))
        if paths:
            return paths[0]
    def get_move(self):
        if not self.alive:
            return {'vec': (1,1,1), 'turn': False, 'fire': False}
        fires = self.get_validshots()
        if fires:
            fires = sorted(fires, key=lambda d: self.rate_vec(d['vec']))
            if self.rate_vec(fires[0]['vec']) <= self.firesafety:
                return fires[0]
        vec = self.get_chase()
        if vec is None or self.rate_vec(vec) > self.chasesafety:
            vec = sorted(self.get_sanevecs(), key=self.rate_vec)
            vec = vec[min(len(vec)-1, random.randint(0,self.jink)) if self.rate_vec(vec[0]) > self.jinkdanger else 0]
        return {'vec': vec, 'turn': True, 'fire': False}
    def move(self):
        move = self.get_move()
        coord = vecAdd(self.coord, move['vec'])
        self.arena.add_expectedallies(coord)
        if move['fire']:
            self.arena.add_expectedshots((coord, move['vec'] if move['turn'] else self.vec))
        return move

VecsCarts = {(0,-1):'N', (0,1):'S', (1,1):'E', (1,-1):'W', (2,1):'U', (2,-1):'D'}

def translateCartVec(cartesian):
    vec = [0]*3
    for v,l in VecsCarts.items():
        if l in cartesian:
            vec[v[0]] = v[1]
    return tuple(vec)

def translateVecCart(vec):
    vec = convertVecTrinary(vec)
    return ''.join(VecsCarts[(i,v)] for i, v in enumerate(vec) if v != 0)

def parsePlaneState(text):
    return (lambda d: {'alive':{'alive': True, 'dead': False}[d[0]], 'coord':tuple(int(c) for c in d[1:4]), 'vec':translateCartVec(d[4]), 'cooldown': int(d[5])})(text.split(' '))

def encodePlaneInstruction(vec, turn, fire):
    return f"{translateVecCart(vec)} {int(bool(turn))!s} {int(bool(fire))!s}"

class CtrlReceiver:
    """Object for interacting through STDIN and STDOUT in a dogfight with an arena, controlled planes, and enemy planes."""
    def __init__(self, logname='danger_log.txt', arenatype=DangerZones, arenaconf=None, planetype=DangerZoner, planeconf=None, enemyname='Enemy', stdin=sys.stdin, stdout=sys.stdout):
        self.logname = logname
        self.arenatype = arenatype
        self.arenaconf = dict(arenaconf) if arenaconf else dict()
        self.planetype = planetype
        self.planeconf = dict(planeconf) if planeconf else dict()
        self.enemyname = enemyname
        self.stdin = stdin
        self.stdout = stdout
        self.log = open('danger_log.txt', 'w')
    def __enter__(self):
        return self
    def __exit__(self, *exc):
        self.log.__exit__()
    def getin(self):
        l = self.stdin.readline()
        self.log.write(f"IN: {l}")
        return l
    def putout(self, content):
        self.log.write(f"OUT: {content}\n")
        print(content, file=self.stdout, flush=True)
    def logout(self, content):
        self.log.write(f"MSG: {content}\n")
    def logerr(self, content):
        self.log.write(f"ERR: {content}\n")
    def run_setup(self, arenasize, rounds):
        self.arena = self.arenatype(dimensions=(arenasize,)*3, **self.arenaconf)
        self.planes = [self.planetype(arena=self.arena, name=f"{self.planetype.__name__} #{i}", **self.planeconf) for i in range(2)]
        self.arena.set_planes(*(Plane(True, None, None, name=f"{self.enemyname} #{i}") for i in range(2)))
        self.arena.set_allies(*self.planes)
    def run_move(self):
        self.arena.tickturn()
        for p in self.planes:
            p.update(**parsePlaneState(self.getin()))
        for p in self.arena.planes:
            p.update(**parsePlaneState(self.getin()))
        for p in self.planes:
            self.putout(encodePlaneInstruction(**p.move()))
    def run(self):
        line = ''
        while not line.startswith('NEW CONTEST '):
            line = self.getin()
        self.run_setup(arenasize=int(line.split(' ')[2])-1, rounds=None)
        while True:
            line = self.getin()
            if line.startswith('NEW TURN'):
                self.run_move()

if True and __name__ == '__main__' and not sys.flags.interactive:
    import time
    DoPlot = False
    #Use the arena object that visualizes progress every turn.
    DangerPlot = True
    #Compute and render a voxel cloud of danger ratings within the arena each turn if visualizing it.
    SparseDangerPlot = False
    #Use a lower resolution for the voxel cloud if visualizing danger ratings.
    TurntablePlot = True
    #Apply a fixed animation to the interactive visualization's rotation if visualizing the arena.
    with CtrlReceiver(logname='danger_log.txt', arenatype=PlottingDangerZones if DoPlot else DangerZones, arenaconf=dict(disabledplots=None if DangerPlot else ('danger'), plotparams=dict(dangerres=2) if SparseDangerPlot else dict(dangeralpha=0.1), plotautoturn=1 if TurntablePlot else 0, plotsavedir=f'PngFrames') if DoPlot else None, planetype=DangerZoner) as run:
        try:
            run.run()
        except Exception as e:
            run.logerr(stringException(e))
```
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.