Programmeerimise algkursus Harjutus 3

Meie eelmises tunnis ehitatud vastaseid sihtiv robot on väga tore, aga kahe või enama roboti puhul võib kergesti jääda nagu kits kahe heinakuhja vahel valides toru edasi-tagasi väntsutama ja korralikult laskmiseni ei jõuagi. Samuti jätab kiiresti liikuvate vastaste puhul tabamistäpsus kõvasti soovida. Vaja oleks seltsimees veidi targemaks teha.

Esimene töö: valida sihtimiseks siga, mis on meile kõige lähemal.

Idee: teeme radariga tiiru ära ja jätame tiiru jooksul leitud sigadest kõige lähemal olnud sea meelde. Järgmise radaritiiru ajal keerame tuki valitud sea suunas ja anname tina, otsides samal ajal uut "lähimat".

Algatuseks peame onScannedRobot sündmusest üleliigse kõntsa ära koristama. Seal istub praegu keeramisnurga arvutamise kood, millest teeme eraldi funktsiooni (meil läheb seda hiljem niikuinii vaja):

    public double arvutaKeeramisnurk(double vastase_peilung) {
        double tuki_suund = getGunHeading();
        double minu_suund = getHeading();

        double vastase_suund = minu_suund + vastase_peilung;
        double keeramisnurk = vastase_suund - tuki_suund;

        return normalRelativeAngle(keeramisnurk);
    }

Teeme globaalmuutujad uus_siga, min_kaugus, siga_sihikul ja laksuTugevus. Selleks lisame neli uut rida oma roboti klassi algusesse:

public class LollRobot extends Robot {

    String siga_sihikul;       // Siga, mida me seekord sihime
    String uus_siga;           // Vahemuutujad uue lähima vastase leidmiseks
    double min_kaugus;
    double laksuTugevus = 2.0; // Kui kõvasti me kavatseme laskma hakata?

...

Radari keerutamisel käivitub iga nähtud vastase kohta onScannedRobot sündmus. Sündmus peab tegema kahte asja:

• Märgib ära tiiru jooksul kõige lähemal olnud sea.
• kui näeb eelmise tiiru ajal märgitud siga, siis annab tina!

Lähima vastase leidmise algoritm töötab järgmiselt:

• Iga radaritiiru alguses seatakse min_kaugus võrdseks lõpmatusega.
• Kontrollitakse, kas vastane on lähemal kui kõik teised sama tiiru jooksul leitud vastased (min_kaugus)
• Kui jah, seatakse min_kaugus võrdseks leitud vastase kaugusega ja uus_siga võrdseks vastase nimega.

onScannedRobot meetod:

    public void onScannedRobot(ScannedRobotEvent e) {
        double vastase_kaugus = e.getDistance();
        double vastase_peilung = e.getBearing();
        String vastase_nimi = e.getName();

        // Kas on meie väljavalitu?
        if(vastase_nimi.equals(siga_sihikul)) {
            // Keerame tuki sea suunda ja anname tina!
            double keeramisnurk = arvutaKeeramisnurk(vastase_peilung);
            turnGunRight(keeramisnurk);
            fire(laksuTugevus);	
        }
 
        // Kas on lähemal, kui kõik teised?
        if(vastase_kaugus < min_kaugus) {
            uus_siga = vastase_nimi;
            min_kaugus = vastase_kaugus;
        }
    }

Run meetod:

 
    public void run() {
        // Ära keera tukki koos kerega ega radarit koos tukiga!
        setAdjustGunForRobotTurn(true);
        setAdjustRadarForGunTurn(true);

        while(true) {
            // Enne otsimist on lähim siga lõpmata kaugel
            sea_kaugus = Double.POSITIVE_INFINITY;

            // Radari scan
            turnRadarLeft(360);

            // Kuningas on surnud, elagu kuningas
            siga_sihikul = uus_siga;
        }
    }

Teine töö: arvutada sea sibamiskiiruse järgi ettelaskmisnurk

Meie praegune robot laseb sinna, kus ta vastast nägi. Inglise keeles nimetatakse seda Head-On targeting.

Kuna kuuli lendamine võtab oma aja, siis liikuvat vastast pole alati mõtet sihtida sinna, kus ta parasjagu on, vaid natuke temast ette poole. Põhimõtteliselt saame liikumiskiiruse (loe: kohvipaksu) pealt "ennustades" arvutada, kus vastane kuuli kohalejõudmise ajaks tegelikult olla võiks ja suunata oma toru sinna.

Joonistame kolmnurga, mille ühes tipus olen mina (R) teises tipus on vastane (s) ja kolmandas tipus vastase asukoht kuuli kohalejõudmise ajal (s'). Kolmnurga üks külg on teada: vastase kaugus. Teised kaks saab hõlpsasti arvutada kuuli lennuaja ja kiiruste järgi.

                                        R
                                       /|
                                      /a|
     kuuli kiirus * kuuli lennuaeg   /  |
                                    /   |  
                                   /____|
                                  s'    s
                                         
                    vastase kiirus * kuuli lennuaeg

Natuke trigonomeetriat meelde tuletades avastame, et ettelaskmisnurga saab arvutada:

ettelaskmisnurk = asin(vastase kiirus / kuuli kiirus)

Kuuli lennuaeg taandub mõnusasti valemist välja. Järelikult on nurga arvutamiseks vaja teada ainult vastase kiirust ja kuuli lennukiirust.

Robocode "füüsikareeglid" annavad kuuli lennukiiruse arvutamiseks järgmise valemi:

kuuli kiirus = 20 - 3 * laksu tugevus

Vastase liikumiskiiruse saab küsida funktsiooniga e.getVelocity().

Paraku ei ole asi päris nii lihtne: meil on vaja teada vastase kiiruse seda komponenti, mis sunnib meid tema sihtimiseks toru keerama, teisisõnu: meid ei huvita kui kiiresti ta meie poole või meist eemale sõidab. Nö "vasakule-paremale" kiirust meie suhtes nimetatakse peenelt lateraalkiiruseks.

Lateraalkiiruse siht on alati täpselt risti vastase peilungiga. Oletame, et vastane liikus punktist s punkti s'. Lateraalkiiruse saamiseks tuleb korrutada kiirus (vektori pikkus) kiirusvektori ja peilungi vahelise nurga siinusega.

                 
                                        s
                                       /|
                                      /a|
                      kiirusvektor   /  |  peilung
                                    /   |  
                                   /____|
                                  s'  
                               lateraalkiirus

Vastase kiirusvektori suuna ehk kursi saame e.getHeading() funktsiooni abil. Kiirusvektori ja peilungi vahelise nurga saamiseks lahutame vastase kursist maha vastase suuna. Viimane on nurk absoluutkoordinaadistikus (null kraadi on mänguväljal otse üleval) ja peaks olema meile juba tuttav suurus.

vastase suund = peilung + minu suund
lateraalkiirus = kiirus * sin(vastase kurss - vastase suund)

Nüüd on meil olemas kõik vajalik, et kirjutada funktsioon ettelaskmisnurga arvutamisks. Kuna aga java.Math pakis leiduvad trigonomeetrilised funktsioonid kasutavad radiaane mitte kraade, tuleb kraadid enne arvutamist radiaanideks konverteerida ja pärast vastupidi tagasi. Abiks on funktsioonid Math.toDegrees(nurk) ja Math.toRadians(nurk).

    public double arvutaEttelaskmisnurk(ScannedRobotEvent e) {
        double vastase_peilung = Math.toRadians(e.getBearing());
        double vastase_kurss = Math.toRadians(e.getHeading());
        double vastase_kiirus = e.getVelocity();
        double minu_suund = Math.toRadians(getHeading());
        double kuuli_kiirus = 20 - 3 * laksuTugevus;

        double vastase_suund = minu_suund + vastase_peilung;

        double lateraalkiirus = vastase_kiirus * Math.sin( vastase_kurss - vastase_suund );

        return Math.toDegrees(Math.asin(lateraalkiirus / kuuli_kiirus));
    }

Jääb veel üle integreerida ettelaskmisnurga arvutamine robotisse (uued read on rohelised):

   public void onScannedRobot(ScannedRobotEvent e) {
       double vastase_kaugus = e.getDistance();
       double vastase_peilung = e.getBearing();
       String vastase_nimi = e.getName();

       // Kas on meie väljavalitu?
       if(vastase_nimi.equals(siga_sihikul)) {
           // Keerame tuki sea suunda ja anname tina!
           double keeramisnurk = arvutaKeeramisnurk(vastase_peilung);
           keeramisnurk = normalRelativeAngle(keeramisnurk + arvutaEttelaskmisnurk(e));
           turnGunRight(keeramisnurk);
           fire(laksuTugevus);
       }

       // Kas on lähemal, kui kõik teised?
       if(vastase_kaugus < min_kaugus) {
           uus_siga = vastase_nimi;
           min_kaugus = vastase_kaugus;
       }
   }

Iseseisev töö

Vastaseid sihtides ei ole mõtet lasta kogu aeg ühesuguse tugevusega kuulidega. Lähedal asuvale vastasele saab rohkem "haiget" teha, kui panna kirja maksimumtugevusega laks. Sinu ülesanne on lisada mingi mõistlik algoritm laksu tugevuse arvutamiseks. Alustuseks loe läbi http://testwiki.roborumble.org/w/index.php?title=Selecting_Fire_Power abiks võib olla ka robot nimega TrackFire.

Vastase valimine kauguse järgi on lahe, aga suuremas seltskonnas ragistades tuleks enne maha lasta see robot, mis otseselt Sind ennast laseb. Täienda sihtmärgi valimise algoritmi nii, et kuuliga pihta saades üritatakse vastu lasta (vähemalt mõnda aega).

Lisalugemist

Käsitletud sihtimismismeetod on äärmiselt primitiivne:

• Eeldab, et vastane liigub sirgjooneliselt (nn lineaarne sihtimine)
• Ei arvesta fakti, et vastane ei saa sõita läbi seina
• Ei arvesta tuki keeramisele kuluvat aega ja laseb seetõttu natuke mööda: Mida rohkem on vastase sihikule võtmiseks vaja tukki keerata, seda ebatäpsem on lask.

Turniiril võitmiseks on vaja midagi natuke "targemat". Võiduhimulised loevad neid lehekülgi ja teevad omad järeldused:

• http://testwiki.roborumble.org/w/index.php?title=Selecting_Fire_Power
• http://testwiki.roborumble.org/w/index.php?title=Linear_targeting
• http://testwiki.roborumble.org/w/index.php?title=Circular_targeting
• http://testwiki.roborumble.org/w/index.php?title=Historical_Velocity_Recall
• http://testwiki.roborumble.org/w/index.php?title=Category:Simple_Targeting_Strategies