UPDATE: isSuicidal () को प्लेन क्लास में जोड़ा गया था, इससे आप यह जांच कर सकते हैं कि कोई प्लेन दीवारों के साथ अपरिवर्तनीय टक्कर के कोर्स पर है या नहीं !!
अद्यतन: अद्यतनकॉलडाउन () सिमूलेटोव से अलग ()
अद्यतन: गैर-जावा प्रविष्टि आवरण, स्पेर द्वारा लिखित , परीक्षण के लिए उपलब्ध है, टिप्पणियों को देखें
UPDATE Zove गेम्स ने इस KOTH के लिए एक भयानक 3D विज़ुअलाइज़र लिखा है , यहाँ PredictAndAVoid से एक काल्पनिक YouTube वीडियो PredictAndAVoid लड़ रहा है।
प्लेन वर्ग के simulateMove () फ़ंक्शन को थोड़ा संशोधित किया गया था ताकि यह अब शांत को अपडेट न करे, शूटिंग के बाद, नए अपडेटकलडाउन () फ़ंक्शन का उपयोग करें। यदि कोई विमान मृतक को समाप्त करने के लिए बाध्य है, तो उसे दुश्मन के चालों का शिकार करने और दीवारों से टकराने से बचने के लिए नया है। अपडेटेड कोड प्राप्त करने के लिए, बस कंट्रोलर और प्लेन क्लासेस को गीथब रेपो में बदलें ।
विवरण
इस चुनौती का लक्ष्य दो डॉगफाइटिंग विमानों को कोड करना है जो किसी अन्य प्रतियोगी द्वारा दो विमानों के खिलाफ सामना करेंगे। हर मोड़ पर आप एक जगह जाते हैं और शूटिंग करने का अवसर मिलता है। बस इतना ही, यह उतना ही सरल है।
हां तकरीबन...
अखाड़ा और संभव चाल
अंतरिक्ष में अखाड़ा एक 14x14x14 दीवार है। प्रतियोगी 1 के विमान स्थानों (0,5,0) और (0,8,0) पर शुरू होते हैं और प्रतियोगी 2 पर (13,5,13) और (13,8,13)। सभी विमान क्षैतिज रूप से उन ऊर्ध्वाधर दीवारों से दूर उड़ान भरते हुए बाहर निकलते हैं जो उनके सबसे करीब हैं।
अब चूँकि आप उड़ने वाले विमान हैं और हेलीकॉप्टर नहीं, आप बस इच्छा को दिशा नहीं बदल सकते हैं या यहाँ तक कि हिलना भी बंद कर सकते हैं, इसलिए प्रत्येक विमान की एक दिशा होती है और वह हर मोड़ पर उस दिशा में एक खिसकाएगा।
संभव निर्देश हैं: उत्तर (एन), दक्षिण (एस), पूर्व (ई), पश्चिम (डब्ल्यू), अप (यू) और डाउन (डी) और उन छह में से कोई भी तार्किक संयोजन। जहां NS अक्ष x अक्ष, WE से y और DU से z तक मेल खाता है। NW, SU और NED दिशाओं के संभावित उदाहरणों के रूप में दिमाग में आते हैं; UD अमान्य संयोजन का एक बढ़िया उदाहरण है।
आप बेशक अपने विमानों की दिशा बदल सकते हैं, लेकिन एक सीमा है, आप केवल अधिकतम 45 डिग्री पर अपनी दिशा बदल सकते हैं। इसकी कल्पना करने के लिए, अपने रूबिक के क्यूब (मुझे पता है कि आपके पास एक है) को पकड़ो और कल्पना करें कि सभी 26 बाहरी छोटे क्यूब्स संभव दिशाएं हैं (एक अक्षर दिशाएं चेहरे हैं, दो अक्षर दिशा किनारों हैं और तीन अक्षर दिशाएं कोने हैं)। यदि आप थोड़ा घन द्वारा दर्शाए गए दिशा में जा रहे हैं, तो आप प्रत्येक घन को दिशा बदल सकते हैं जो आपका स्पर्श करता है (तिरछे स्पर्श करने वाले गिना जाता है, लेकिन केवल दृश्य रूप से स्पर्श करना, जो घन से स्पर्श नहीं कर रहा है)।
सभी विमानों ने यह इंगित करने के बाद कि वे किस दिशा में बदलना चाहते हैं, वे ऐसा करते हैं और एक साथ एक टाइल को स्थानांतरित करते हैं।
आप एक वैध दिशा में जाने का विकल्प भी चुन सकते हैं, लेकिन जिस दिशा में आप जा रहे हैं, उस दिशा में अपनी दिशा बदलने के बजाय, जिस दिशा में आप जा रहे हैं, उसमें उड़ते रहें। यह एक कोने के आसपास जाने वाली कार और गलियों को बदलने वाली कार के बीच के अंतर के अनुरूप है।
शूटिंग और मर रहा है
आप प्रति बार एक बार में शूट कर सकते हैं और यह उसी समय तय करना होता है जब आप तय करते हैं कि किस दिशा में उड़ना है और क्या आप अपना विमान (और विस्तार से, अपनी बंदूक) उसी दिशा में रखना चाहते हैं या नहीं। आपके विमान के चलने के ठीक बाद गोली चलती है। शूटिंग के बाद एक मोड़ पर शांत हो जाता है, तीसरे मोड़ पर, आप फिर से जाने के लिए अच्छे हैं। आप केवल उस दिशा में शूट कर सकते हैं, जिसमें आप उड़ रहे हैं। एक गोली तत्काल होती है और एक सीधी रेखा में तब तक उड़ती है, जब तक वह दीवार या विमान से टकरा नहीं जाती।
जिस तरह से आप दिशा बदलने के साथ-साथ 'लेन बदल सकते हैं' को ध्यान में रखते हैं, इसका मतलब है कि आप कुछ तिरछे, एकल लाइनों के अलावा, आप के सामने 3x3 लाइनों के एक कॉलम को धमकी दे सकते हैं।
यदि यह एक विमान से टकराता है, तो यह विमान मर जाता है और तुरंत बोर्ड से गायब हो जाता है (क्योंकि यह पूरी तरह से फट जाता है या कुछ और)। बुलेट केवल एक विमान को सबसे अधिक मार सकती है। गोलियों की एक साथ शूटिंग होती है, इसलिए दो विमान एक-दूसरे को गोली मार सकते हैं। दो गोलियां हवा में नहीं टकरा सकती हैं हालांकि (दुख की बात है, मुझे पता है)।
हालाँकि, दो विमान आपस में टकरा सकते हैं (यदि वे एक ही घन में समाप्त होते हैं और एक ही विमान में समाप्त हुए बिना एक दूसरे को पार नहीं करते हैं), और इसके परिणामस्वरूप दोनों विमान मरते हैं (और पूरी तरह से विस्फोट होते हैं)। आप उस दीवार में भी उड़ सकते हैं जिसके परिणामस्वरूप विमान को मरने के बारे में सोचा जाएगा और उसके कार्यों के बारे में सोचने के लिए कोने में रखा जाएगा। शूटिंग करने से पहले टकराव हो जाते हैं।
नियंत्रक के साथ संचार
मैं जावा के साथ-साथ अन्य भाषाओं में भी प्रविष्टियां स्वीकार करूंगा। यदि आपकी प्रविष्टि जावा में है, तो आपको STDIN के माध्यम से इनपुट मिलेगा और STDOUT के माध्यम से आउटपुट मिलेगा।
यदि आपकी प्रविष्टि जावा में है, तो आपकी प्रविष्टि में निम्न वर्ग का विस्तार होना चाहिए:
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?
}
}DumbPlanes अन्य प्रविष्टियों के साथ टूर्नामेंट में शामिल होगा, इसलिए यदि आप अंतिम अंत में हैं, तो यह DumbPlanes की तुलना में कम से कम बेहतर नहीं करने के लिए आपकी अपनी गलती है।
प्रतिबंध
KOTH विकि में उल्लिखित प्रतिबंध लागू होते हैं:
- नियंत्रक, रनटाइम या अन्य सबमिशन के साथ छेड़छाड़ करने का कोई भी प्रयास अयोग्य घोषित किया जाएगा। सभी प्रस्तुतियाँ केवल उन इनपुट और भंडारण के साथ काम करना चाहिए जो उन्हें दिए गए हैं।
- बॉट को विशिष्ट अन्य बॉट को हरा या समर्थन करने के लिए नहीं लिखा जाना चाहिए। (यह दुर्लभ मामलों में वांछनीय हो सकता है, लेकिन अगर यह चुनौती की एक प्रमुख अवधारणा नहीं है, तो इसे बेहतर तरीके से खारिज किया जा सकता है)।
- मैं उन संसाधनों को अयोग्य घोषित करने का अधिकार सुरक्षित रखता हूं जो संसाधनों की उचित मात्रा के साथ परीक्षण चलाने के लिए बहुत अधिक समय या स्मृति का उपयोग करते हैं।
- एक बॉट को मौजूदा एक के रूप में सटीक एक ही रणनीति को लागू नहीं करना चाहिए, जानबूझकर या गलती से।
अपने सबमिशन का परीक्षण
यहां से कंट्रोलर कोड डाउनलोड करें । अपने सबमिशन को समथिंग के रूप में जोड़ें। जावा। [] और नाम [] प्रविष्टियों में अपने विमान के लिए प्रविष्टियों को शामिल करने के लिए नियंत्रक.जावा को संशोधित करें। एक ग्रहण परियोजना के रूप में या javac -d . *.javaउसके साथ सब कुछ संकलित करें , फिर नियंत्रक के साथ चलाएं java Planes/Controller। प्रतियोगिता का एक लॉग test.txtअंत में एक स्कोरबोर्ड के साथ होगा। आप matchUp()दो प्रविष्टियों के साथ सीधे कॉल भी कर सकते हैं, एक दूसरे के खिलाफ दो विमानों का परीक्षण करने के लिए तर्क के रूप में।
लड़ाई जीतना
लड़ाई का विजेता वह होता है जिसके पास अंतिम विमान उड़ान होता है, अगर 100 मोड़ के बाद, अभी भी 1 से अधिक टीम शेष है, तो सबसे अधिक विमानों वाली टीम ने जीत छोड़ दी। यदि यह समान है, तो यह एक ड्रा है।
स्कोरिंग और प्रतियोगिता
अगला आधिकारिक टूर्नामेंट तब चलाया जाएगा जब मौजूदा बाउंटी रन आउट हो जाएगी।
प्रत्येक प्रविष्टि हर दूसरे प्रविष्टि (कम से कम) 100 बार लड़ेगी, प्रत्येक मैच का विजेता 100 में से सबसे अधिक जीत वाला है और उसे 2 अंकों से सम्मानित किया जाएगा। ड्रॉ के मामले में, दोनों प्रविष्टियों को 1 अंक से सम्मानित किया जाता है।
प्रतियोगिता का विजेता अधिकांश अंकों के साथ एक है। ड्रॉ होने की स्थिति में, विजेता वह होता है जो ड्रॉ की गई प्रविष्टियों के बीच मैच में जीता है।
प्रविष्टियों की मात्रा के आधार पर, प्रविष्टियों के बीच झगड़े की मात्रा में काफी वृद्धि हो सकती है, मैं पहले टूर्नामेंट के बाद 2-4 सर्वश्रेष्ठ प्रविष्टियों का भी चयन कर सकता हूं और उन झगड़ों के बीच एक elites टूर्नामेंट सेट कर सकता हूं (और संभवतः अधिक राउंड प्रति लड़ाई)
(प्रारंभिक) स्कोरबोर्ड
हमें एक नई प्रविष्टि मिली है जो दृढ़ता से एक और रोमांचक टूर्नामेंट में दूसरा स्थान हासिल करती है , ऐसा लगता है कि प्रिडिक्टअवॉइड को छोड़कर सभी के लिए गोलीबारी करना अविश्वसनीय रूप से कठिन है। ध्यान दें कि यह टूर्नामेंट विमानों के प्रत्येक सेट के बीच केवल 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इन चार पंक्तियों से संकेत मिलता है कि आपके दोनों विमान जीवित हैं, क्रमशः [१३, both,११] और [१३,५,१३], दोनों उत्तर की ओर हैं, दोनों शून्य कोल्डाउन के साथ हैं। पहला शत्रु विमान मृत है, और दूसरा जीवित है, [0,8,0] और शून्य कोल्डाउन के साथ दक्षिण की ओर।
इस बिंदु पर आपके प्रोग्राम को निम्न के समान दो लाइनों का उत्पादन करना चाहिए:
NW 0 1
SU 1 0यह इंगित करता है कि आपका पहला विमान नॉर्थवेस्ट की यात्रा करेगा, इसकी वर्तमान हेडिंग से मुड़कर, और यदि संभव हो तो शूटिंग कर सकता है। आपका दूसरा प्लेन साउथयूपी की यात्रा करेगा, साउथयूपी का सामना करेगा, शूटिंग नहीं।
अब आप ROUNDS LEFT 18इसके बाद आते हैं NEW TURNआदि यह तब तक जारी रहता है जब तक कि कोई जीत या गोल आउट नहीं हो जाता है, जिस बिंदु पर आपको NEW FIGHTअपडेटेड फाइट काउंट और स्कोर के साथ एक और लाइन मिलती है , संभवतः पूर्व में ए NEW OPPONENT।
