/*******************************************************************************
 * Třída UFO_3a obsahuje vzorové řešení pro třídu UFO, která
 * simuluje dopravní prostředek mimozemšťanů, pomocí nějž se pohybují
 * vesmírem. Úkolem hráče je dopravit všechna UFO ze startovní rampy do
 * hangárů. Cestopu musí dávat pozor, aby nenarazil do planet a jiných UFO.
 * Hráč může ovládat současně tolik UFO, na kolik si troufne.
 * <p>
 * Při první variantě hry žádá hráč o UFO dispečera RDispečer (preferuje
 * přímé ovládání Rychlosti). Úkolem hráče je požádat dispečera postupně
 * o jednotlivá UFO a přímým zadáváním jejich rychlosti prostřednictvím
 * volání metody setRychlost(int,int);
 * <p>
 * Při druhé variantě hry žádá hráč o UFO dispečera ZDispečer (preferue
 * ovládní pohybu přes Zrychlení). Úkolem hráče je opět převzít od dispečera
 * jednotlivá UFO a dopravit je do hangárů, avšak tentokrát ovlivňuje jejich
 * pohyb přímo klávesami. Stiskem kláves ale nenastavuje rychlost UFO,
 * ale tah jeho motorů a tím i velikost jeho zrychlení resp. zpomalení.
 * <p>
 * Druhá varianta lépe simuluje stav ve vesmíru, kde neexistuje žádné tření,
 * takže při zapnutých motorech lod pořád zrychluje či brzdí a naopak
 * při vypnutých motorech si udržuje konstantní rychlost.
 * <p>
 * @author     Rudolf Pecinovský
 * @version    1.00, červen 2004
 */
public class UFO_3a extends UFO
{
//== KONSTANTNÍ ATRIBUTY TŘÍDY =================================================

//     /** Změna tahu při posunutí plynu o jeden stupeň
//      *  (a také při stisku šipky). */
//     public static final double DTAH = 2;



//== PROMĚNNÉ ATRIBUTY TŘÍDY ===================================================
//== KONSTANTNÍ ATRIBUTY INSTANCÍ ==============================================

    private Talíř talíř;
    private Číslo číslo;
    private int   pořadí;


//== PROMĚNNÉ ATRIBUTY INSTANCÍ ================================================

    private double xTah,      yTah;
    private double xRychlost, yRychlost;
    private double xPos,      yPos;



//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ TŘÍDY ========================================
//== OSTATNÍ METODY TŘÍDY ======================================================

//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================

    /***************************************************************************
     * Předá konstruktoru talíř tvořící kostru UFO,
     * jeho pořadí v rámci vytvořených UFO
     * a maximálníbtah motorů, který ovlivňuje změny zrychlení instance.
     *
     * @param talíř   Odkaz na talíř tvořící kostru UFO.
     * @param pořadí  Pořadí konstruovaného UFO v rámci již vytvořených.
     * @param tah     Maximální tah motorů udává v jakých přírůstcích
     *                se bude měnit zrychlení.
     */
    public UFO_3a(Talíř talíř, int pořadí)
    {
        super( talíř, pořadí );
        xPos = talíř.getX();
        yPos = talíř.getY();

        this.talíř  = talíř;
        this.pořadí = pořadí;
        this.číslo  = new Číslo( pořadí, xPos, yPos );

        nakresli();
    }


//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ INSTANCÍ =====================================

    /***************************************************************************
     * Vrátí pořadové číslo UFO obdržené při konstrukci.
     *
     * @return Požadované pořadové číslo.
     */
    public int getČíslo()
    {
        return pořadí;
    }


    /***************************************************************************
     * Vrátí aktuální velikost tahu motoru ve vodorovném směru
     * a tím i velikost vodorovného zrychlení, resp. zpomalení UFO.
     * Velikost tahu udává o kolik se změní rychlost UFO za jednu sekundu.
     *
     * @return  Aktuální velikost tahu. Pro zrychlování doprava je tah kladný,
     *          pro zrychlování doleva je tah záporný.
     */
    public double getXTah()
    {
        return xTah;
    }


    /***************************************************************************
     * Vrátí aktuální velikost tahu motoru ve svislém směru
     * a tím i velikost svislého zrychlení, resp. zpomalení UFO.
     * Velikost tahu udává o kolik se změní rychlost UFO za jednu sekundu.
     *
     * @return  Aktuální velikost tahu. Pro zrychlování dolů je tak kladný,
     *          pro zrychlování vzhůry je tah záporný.
     */
    public double getYTah()
    {
        return yTah;
    }


    /***************************************************************************
     * Vrátí aktuální velikost rychlost ve vodorovném směru,
     * tj. počet bodů, o které se UFO přesune za jednu sekundu.
     *
     * @return  Aktuální velikost rychlosti. Při pohybu doprava je rychlost
     *          kladná, při pohybu doleva je záporná.
     */
    public double getXRychlost()
    {
        return xRychlost;
    }


    /***************************************************************************
     * Vrátí aktuální velikost rychlost ve svislém směru,
     * tj. počet bodů, o které se UFO přesune za jednu sekundu.
     *
     * @return  Aktuální velikost rychlosti. Při pohybu dolů je rychlost kladná,
     *          při pohybu vzhůru je záporná.
     */
    public double getYRychlost()
    {
        return yRychlost;
    }


    /***************************************************************************
     * Nastaví rychlost jako počet bodů, o něž se UFO přesune za jednu sekundu.
     *
     * @param x  Požadovaná velikost rychlosti ve vodorovném směru
     *           (kladná čísla doprava, záporná doleva).
     * @param x  Požadovaná velikost rychlosti ve svislém směru
     *           (kladná čísla dolů, záporná vzhůru).
     */
    public void setRychlost( double x, double y )
    {
        xRychlost = x;
        yRychlost = y;
    }


    /***************************************************************************
     * Vrátí x-ovou souřadnici pozice instance.
     *
     * @return  x-ová souřadnice.
     */
    public double getX()
    {
        return xPos;
    }


    /***************************************************************************
     * Vrátí y-ovou souřadnici pozice instance.
     *
     * @return  y-ová souřadnice.
     */
    public double getY()
    {
        return yPos;
    }



//== PŘEKRYTÉ METODY IMPLEMENTOVANÝCH ROZHRANÍ =================================
//== PŘEKRYTÉ ABSTRAKTNÍ METODY RODIČOVSKÉ TŘÍDY ===============================
//== PŘEKRYTÉ KONKRÉTNÍ METODY RODIČOVSKÉ TŘÍDY ================================

    /***************************************************************************
     * Vrací textovou reprezentaci dané instance
     * používanou především k ladícím účelům.
     *
     * @return Název třídy následovnaý podtržítkem a "rodným číslem" instance.
     */
    public String toString()
    {
        return "UFO_" + pořadí;
    }


//== NOVĚ ZAVEDENÉ METODY INSTANCÍ =============================================

    /***************************************************************************
     * Zvětší vodorovný tah motorů a tím i zrychlení (= přírustek rychlosti)
     * o jeden díl maximálního tahu, tj. o DTAH.
     */
    public void vpravo()
    {
        xTah = xTah + DTAH;
    }


    /***************************************************************************
     * Zmenší vodorovný tah motorů a tím i zrychlení (= přírustek rychlosti)
     * o jeden díl maximálního tahu, tj. o DTAH.
     */
    public void vlevo()
    {
        xTah = xTah - DTAH;
    }


    /***************************************************************************
     * Zvětší svislý tah motorů a tím i zrychlení (= přírustek rychlosti)
     * o jeden díl maximálního tahu, tj. o DTAH.
     */
    public void dolů()
    {
        yTah = yTah + DTAH;
    }


    /***************************************************************************
     * Zmenší svislý tah motorů a tím i zrychlení (= přírustek rychlosti)
     * o jeden díl maximálního tahu, tj. o DTAH.
     */
    public void vzhůru()
    {
        yTah = yTah - DTAH;
    }


    /***************************************************************************
     * Zastaví motory (zadá nulový tah) a tím nastaví nulové zrychlení.
     * Od tohoto okamžiku až do přístího zapnutí motorů se bude UFO pohybovat
     * stále stejně rychle.
     */
    public void vypniMotory()
    {
        xTah = 0;
        yTah = 0;
    }


    /***************************************************************************
     * Nastaví nové souřadnice instance tak,
     * že k současné hodnotě souřadnic přičte aktuální rychlost.
     * Je-li nastavené nenulové zrychlení (tah motorů), musí nejprve
     * připočíst k rychlosti aktuální zrychlení a tak nastavit
     * její aktuální velikost. Teprve tu může přičíst k hodnotě souřadnic.
     * <p>
     * Při připočítávání zrychlení k rychlosti a rychlosti k pozici je třeba
     * počítat s tím, že Dispčer volá tuto metodu mnohokrát za sekundu.
     * Proto předává jako parametr počet volání za sekundu, aby program věděl,
     * čím má nastavenou velikost zrychlení či rychlosti podělit,
     * aby získal správnou velikost opakovaného přírůstku.
     */
    public void popojeď( int frekvence )
    {
        //Musíme zvýšit rychlost o odpovídající zlomek velikosti tahu
        //Změní-li se za vteřinu rychlost o velikost tahu,
        //změní se za (1/frekvence) část vteřiny o (1/frekvence) část tahu
        xRychlost = xRychlost + (xTah / frekvence);
        yRychlost = yRychlost + (yTah / frekvence);

        //Musíme změnit pozici o odpovídající zlomek velikosti rychlosti
        //Změní-li se za vteřinu pozice o velikost rychlosti,
        //změní se za (1/frekvence) část vteřiny o (1/frekvence) část rychlosti
        xPos = xPos + (xRychlost / frekvence);
        yPos = yPos + (yRychlost / frekvence);

        //Pro talíř i číslo nastavíme novou pozici
        talíř.setPozice( xPos, yPos );
        číslo.setPozice( xPos, yPos );
    }


    /***************************************************************************
     * Vykreslí obraz své instance ve vesmíru.
     */
    public void nakresli()
    {
        talíř.nakresli();
        číslo.nakresli();
    }



//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================
//== VNOŘENÉ A VNITŘNÍ TŘÍDY ===================================================
//== TESTY A METODA MAIN =======================================================
}

