रोबोकोड में पहला कदम

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

• http://www.youtube.com/watch?v=dqHmp_kMz-U - द्वंद्वयुद्ध
• http://www.youtube.com/watch?v=eqlPbtO3rQY - द्वंद्वयुद्ध
• http://www.youtube.com/watch?v=zx7xFJiBGZQ - फाइट,> 2 रोबोट, प्रत्येक अपने लिए
• http://www.youtube.com/watch?v=EJPskFGvGi8 - पोर्टिया रोबोट (फ़िरोज़ा) पर ध्यान दें - यह इस श्रेणी के सर्वश्रेष्ठ सेनानियों में से एक है

परिचय

इस लेख में, मेरा मतलब है कि पाठक एल्गोरिदम और ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के सामान्य सिद्धांतों के साथ-साथ जावा भाषा से परिचित है, या उस पर अन्य भाषाओं के अपने ज्ञान को प्रोजेक्ट करने में सक्षम है।

Robocode में 4 आधिकारिक टूर्नामेंट हैं:

• द्वंद्व, 800 से 600 के बीच मैदान पर 2 रोबोट
• फाइट (मेले), प्रति 1000 क्षेत्र पर 10 रोबोट
• टीमों, 1200 पर 1200 प्रति फ़ील्ड 5 रोबोट की 2 टीमें
• डबल द्वंद्वयुद्ध (ट्विनड्यूल), 2 रोबोटों की 2 टीमें 800 से 800 के मैदान पर

द्वंद्वयुद्ध में 4 भार श्रेणियां हैं और एक लड़ाई:

• नैनो <= 249 निष्पादन योग्य कोड के बाइट्स
• माइक्रो <= 749 निष्पादन योग्य कोड के बाइट्स
• मिनी <= 1499 निष्पादन योग्य कोड के बाइट्स
• मेगा (सामान्य) - असीमित

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

ट्रेनिंग

अपने चैंपियन की प्रोग्रामिंग शुरू करने के लिए, आपको कम से कम डाउनलोड और इंस्टॉल करने की आवश्यकता है:

• जावा का नवीनतम संस्करण (हालांकि, इस समय खेल आधिकारिक तौर पर केवल जावा 6 का समर्थन करता है, इसलिए रोबोट को इस संस्करण के लिए संकलित किया जाना चाहिए)
• रोबोकोड का नवीनतम संस्करण (फिर से, आधिकारिक प्रतियोगिताओं में नवीनतम संस्करण समर्थित नहीं है, इसलिए सुनिश्चित करें कि रोबोट एपीआई का उपयोग नहीं करता है जो वर्तमान में समर्थित संस्करण में नहीं हैं)।

मैं अत्यधिक डाउनलोड और इंस्टॉल करने की सलाह देता हूं:

• किसी भी आधुनिक जावा आईडीई का नवीनतम संस्करण (मैंने यहां किसी को भी विज्ञापित नहीं किया है, यदि मेरे कोई प्रश्न हैं, तो कृपया पीएम में)
• चींटी निर्माण प्रणाली

खेल भौतिकी

क्योंकि इस खंड के साथ, लेख बहुत बड़ा हो गया है, और यह खंड काफी उन्नत है और पहले चरणों को लेने के लिए इसे पढ़ा और समझा नहीं जाना चाहिए, मैंने इसे एक अलग लेख में रखा, जिसे मैं शीघ्र ही प्रकाशित करूंगा।

UPD: भौतिकी पर एक लेख प्रकाशित http://habrahabr.ru/post/147956/

रोबोट नियंत्रण और बाहरी दुनिया के साथ बातचीत

सामान्य तौर पर, खेल में कक्षाओं की एक पूरी पदानुक्रम होती है जिससे आप अपने रोबोट को लिखने के लिए विरासत में प्राप्त कर सकते हैं। एक "सरल" रोबोकोड है। रोबोट वर्ग जो एक समय में केवल एक कमांड निष्पादित कर सकता है, अर्थात। या तो चलते हैं, या घुमाते हैं, या गोली मारते हैं (हालांकि, एक बोनस है - ऐसे रोबोट दीवारों से टकराव से नुकसान नहीं पहुंचाते हैं)। लेकिन मेरी राय में, इस तरह के रोबोट की प्रोग्रामिंग इसके विपरीत अधिक कठिन है और मैं लुटेकोड.आडवंटेडरोबॉट क्लास से विरासत में प्राप्त करने के लिए भविष्य में (मैं इस धारणा से आगे बढ़ूंगा कि आपने मेरी सिफारिश का पालन किया है) से सलाह देते हैं, जो एक बार में सभी भागों का प्रबंधन कर सकता है। Robocode.TeamRobot वर्ग भी निर्बाध नहीं है, जो आपको कमांड बनाने की अनुमति देता है, लेकिन यह एक अलग लेख के लिए एक अलग विषय है।

रोबोट को कई कमांड द्वारा नियंत्रित किया जाता है, लेकिन मैं केवल सबसे महत्वपूर्ण चीज़ दूंगा:

• सेटअहेड - पिक्सल की निर्दिष्ट संख्या के अनुसार अधिकतम गति पर (और अगर रोबोट वर्तमान में पीछे की ओर बढ़ रहा है तो धीमा)। यदि तर्क नकारात्मक है, तो रोबोट वापस चला जाता है
• setFire और setFireBullet - दी गई शक्ति के साथ शूट करें।
• setTurnRightRadians, setTurnLeftRadians, setTurnGunRightRadians, setTurnGunLeftRadians, setTurnRadarRightRadians, setTurnRadarLeftRadians, रेडियन में दिए गए दिशा-निर्देश के अनुसार संबंधित भागों का घूर्णन - (रेडियन में वहाँ)। * राइटराडियन - संबंधित भाग को दक्षिणावर्त घुमाता है, * वाममार्गी, क्रमशः, वामावर्त।

प्रत्येक मोड़ की शुरुआत में, रोबोट को अंतिम कमांड के निष्पादन के दौरान होने वाली घटनाओं का एक सेट प्राप्त होता है। बहुत सारी घटनाएँ हैं और मैं उनमें से केवल सबसे महत्वपूर्ण चीज़ों को दूंगा:

• StatusEvent - रोबोट की स्थिति (स्थिति, गति, भागों की दिशा, आदि)।
• डेथइवेंट - रोबोट अभी नष्ट हो चुका है।
• BulletHitEvent - एक रोबोट की गोली दूसरे रोबोट को लगी।
• HitByBulletEvent - एक दुश्मन की गोली रोबोट को मारा।
• HitRobotEvent - दुश्मन के साथ एक टक्कर हुई।
• HitWallEvent - एक दीवार की टक्कर हुई।
• स्कैनरोबोटेवेंट - अंतिम चाल दुश्मन द्वारा पता लगाया गया था। इस घटना में दुश्मन के बारे में कुछ जानकारी होती है (वह सब जो उसकी स्थिति, उसकी ऊर्जा, उसके आंदोलन की दिशा की गणना करने के लिए आवश्यक है।

विधानसभा की तैयारी

यदि किसी कारण से आप असेंबली के लिए चींटी का उपयोग नहीं करने का निर्णय लेते हैं, तो आप इस अनुभाग को छोड़ सकते हैं। आप यहां से रिपॉजिटरी डाउनलोड कर सकते हैं: https://github.com/aleksey-zhidkov/HabrahabrTutorial , या अपने खुद के हाथों से निम्न फ़ोल्डर संरचना बनाएं:

 / हैब्रह्राट्यूटर्स
 + - / src
    - build.properties
    - build.xml

Build.properties फ़ाइल में निम्न सामग्री है:

  bin.dir = बिन
 buildds.dir = बनाता है
 robocode.dir =;  Robocode होम डाइरेक्टरी का पथ, डिफ़ॉल्ट रूप से C: \\ Robocode (मैं जावा गुण प्रारूप पर आपका ध्यान आकर्षित करता हूं और स्लैश बच जाना चाहिए)
 robocode.jar = $ {robocode.dir} \\ libs \\ robocode.jar 

बिल्ड.xml फ़ाइल में निम्न सामग्री है:

<?xml version="1.0" encoding="UTF-8"?> <project name="HabrahabrTutorial" basedir="." default="release"> <property file="build.properties"/> <property name="robot.version" value="0.1"/> <property name="robot.package" value="ru.jdev.habrahabr"/> <property name="robot.path" value="ru/jdev/habrahabr"/> <property name="robot.name" value="HabrahabrTutorial"/> <path id="src.files"> <pathelement location="src"/> </path> <target name="init"> <mkdir dir="${bin.dir}"/> </target> <target name="compile" depends="init" description="Compiles source files"> <javac destdir="${bin.dir}" debug="on" debuglevel="lines,vars,source" optimize="yes" target="1.6"> <src refid="src.files"/> <classpath> <pathelement location="${robocode.jar}"/> </classpath> </javac> </target> <target name="clean" description="Deletes all previous build artifacts"> <delete dir="${bin.dir}"/> </target> <target name="release" depends="clean, compile"> <copy todir="${bin.dir}"> <fileset dir="src"/> </copy> <echo file="${bin.dir}/${robot.path}/${robot.name}.properties">robocode.version=1.7.3 robot.java.source.included=true robot.version=${robot.version} robot.author.name=Alexey jdev Zhidkov robot.classname=${robot.package}.${robot.name} robot.name=${robot.name} robot.description=Tutorial robot for habrahabr.ru </echo> <jar destfile="${builds.dir}\${robot.package}.${robot.name}_${robot.version}.jar" compress="true"> <fileset dir="${bin.dir}"/> </jar> <copy todir="${robocode.dir}\robots\"> <fileset file="${builds.dir}\${robot.package}.${robot.name}_${robot.version}.jar"/> </copy> <delete includeEmptyDirs="true"> <fileset dir="${bin.dir}" includes="**/*"/> </delete> </target> </project> 

यदि आपने सब कुछ सही किया है, तो प्रोजेक्ट के रूट में चींटी कमांड चलाने के बाद, आपको HabrahabrTutorial \ buildds \ ru.jdev.habrahabr.HabrahabrTutorial_0.1.jar फ़ाइल को देखना चाहिए, जिसमें फ़ाइल ru \ jdev \ habrahabr \ HabrahabrTutorial.properties शामिल होनी चाहिए। (उन लोगों के लिए जो जावा से दूर हैं, मैं समझाता हूं कि जार एक नियमित ज़िप संग्रह है जिसे किसी भी संग्रहकर्ता के साथ खोला जा सकता है)

एक रोबोट बनाना

पिछले अनुभाग से निर्देशिका में अपनी पसंद के विकास के माहौल में एक परियोजना बनाएं, लाइब्रेरी को $ {robocode_home} /libs/robocode.jar से कनेक्ट करें। फिर पर्यावरण को कॉन्फ़िगर करें ताकि यह या तो कोड को रोबोट के साथ फ़ोल्डर में स्वयं संकलित करे, या यह कि विधानसभा के दौरान पिछले अनुभाग से स्क्रिप्ट का उपयोग करता है। अंत में, निम्न कोड के साथ एक नया वर्ग ru.jdev.habrahabr.HabrahabrTutorial बनाएं:

 package ru.jdev.habrahabr; import robocode.AdvancedRobot; public class HabrahabrTutorial extends AdvancedRobot { @Override public void run() { while (true) { /** *      ,            *        */ execute(); } } } 

गेम लॉन्च करें, बैटल को चुनें -> नया और सुनिश्चित करें कि ru.jdev.habrahabr.HabrahabrTutorial रोबोट की सूची में दिखाई देता है।

चरण एक: मृत्यु के बाद बाहर निकलें, दुश्मन की स्थिति की गणना करें, रडार को नियंत्रित करें और ड्रा करें।

हम कोड को निम्नलिखित रूप में लाते हैं (यहां सभी टिप्पणियाँ सीधे कोड में दी गई हैं। इसके अलावा, बाद में, जोड़ा लाइनों या विधियों को टिप्पणी के साथ चिह्नित किया जाता है / * + * /, परिवर्तित लाइनों या विधियों को टिप्पणी के साथ चिह्नित किया जाता है / * ~ * /):

 package ru.jdev.habrahabr; import robocode.AdvancedRobot; import robocode.DeathEvent; import robocode.ScannedRobotEvent; import robocode.util.Utils; import java.awt.*; import java.awt.geom.Point2D; import static java.lang.Math.signum; import static java.lang.Math.toRadians; public class HabrahabrTutorial extends AdvancedRobot { /*+*/private static final double RADIANS_5 = toRadians(5); /*+*/private boolean isAlive = true; /*+*/private double enemyX = -1; /*+*/private double enemyY = -1; @Override public void run() { /*+*/setTurnRadarRightRadians(Double.POSITIVE_INFINITY); //          /*~*/while (isAlive) { //         true,       /*+*/if (enemyX > -1) { //    /*+*/final double radarTurn = getRadarTurn(); /*+*/setTurnRadarRightRadians(radarTurn); /*+*/} /** *      ,            *        */ execute(); } } /*+*/private double getRadarTurn() { //       //     : final double alphaToEnemy = angleTo(getX(), getY(), enemyX, enemyY); //  ,     ,      (Utils,    Robocode ): final double sign = (alphaToEnemy != getRadarHeadingRadians()) ? signum(Utils.normalRelativeAngle(alphaToEnemy - getRadarHeadingRadians())) : 1; //  5         return Utils.normalRelativeAngle(alphaToEnemy - getRadarHeadingRadians() + RADIANS_5 * sign); //  ,     setTurnRadarRightRadians,          //    } @Override /*+*/public void onScannedRobot(ScannedRobotEvent event) { /** ScannedRobotEvent       , ,   ,   *  ,  (    -,     )     */ //     final double alphaToEnemy = getHeadingRadians() + event.getBearingRadians(); //     enemyX = getX() + Math.sin(alphaToEnemy) * event.getDistance(); enemyY = getY() + Math.cos(alphaToEnemy) * event.getDistance(); } @Override /*+*/public void onDeath(DeathEvent event) { isAlive = false; } @Override /*+*/public void onPaint(Graphics2D g) { // ,      //       ,            //       Paint if (enemyX > -1) { g.setColor(Color.WHITE); g.drawRect((int) (enemyX - getWidth() / 2), (int) (enemyY - getHeight() / 2), (int) getWidth(), (int) getHeight()); } } /** *  Robocode    - 0        : * 90 - , 180 - , 270 - , 360 - . * <p/> * -          . *  ,      , , ,    */ /*+*/private static double angleTo(double baseX, double baseY, double x, double y) { double theta = Math.asin((y - baseY) / Point2D.distance(x, y, baseX, baseY)) - Math.PI / 2; if (x >= baseX && theta < 0) { theta = -theta; } return (theta %= Math.PI * 2) >= 0 ? theta : (theta + Math.PI * 2); } } 

चरण दो: शुरू करना

हम यादृच्छिक कक्षीय आंदोलन की अशिष्टताओं का एहसास करते हैं। कक्षीय का मतलब है कि यदि दुश्मन अभी भी खड़ा है, और यादृच्छिक लगातार एक दिशा देगा, तो हमारा टैंक दुश्मन के चारों ओर सर्कल बना देगा। और यादृच्छिक घटक हमारे टैंक को थोड़ा और कठिन लक्ष्य बना देगा। आंदोलन को लागू करने के लिए, हम दो तरीके जोड़ते हैं:

 private double getDistance() { //     return 200 - 400 * random(); } private double getBodyTurn() { //       final double alphaToMe = angleTo(enemyX, enemyY, getX(), getY()); //      (  ,  ) ... final double lateralDirection = signum((getVelocity() != 0 ? getVelocity() : 1) * Math.sin(Utils.normalRelativeAngle(getHeadingRadians() - alphaToMe))); //     final double desiredHeading = Utils.normalAbsoluteAngle(alphaToMe + Math.PI / 2 * lateralDirection); //     final double normalHeading = getVelocity() >= 0 ? getHeadingRadians() : Utils.normalAbsoluteAngle(getHeadingRadians() + Math.PI); //     return Utils.normalRelativeAngle(desiredHeading - normalHeading); } 

और इस शर्त के अंदर कि मुख्य लूप में दुश्मन का पता चला है, निम्नलिखित पंक्तियाँ जोड़ें:

  setTurnRadarRightRadians(radarTurn); /*+*/ final double bodyTurn = getBodyTurn(); /*+*/ setTurnRightRadians(bodyTurn); /*+*/ /*+*/ if (getDistanceRemaining() == 0) { /*+*/ final double distance = getDistance(); /*+*/ setAhead(distance); /*+*/ } } 

तीन चरण: आग!

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

 private double getGunTurn() { //  :       ,      : return Utils.normalRelativeAngle(angleTo(getX(), getY(), enemyX, enemyY) - getGunHeadingRadians()); } 

और मुख्य लूप में तीन लाइनें जोड़कर:

  setAhead(distance); } /*+*/ final double gunTurn = getGunTurn(); /*+*/ setTurnGunRightRadians(gunTurn); /*+*/ setFire(2); } 

आगे क्या है

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

PS यह मेरा पहला ट्यूटोरियल है, इसलिए मुझे रचनात्मक आलोचना करने में खुशी होगी