Zdrojový kód k 6. prednáške

/**
 * Prida novu loptu do ihriska
 *
 * @param x
 *            x-ova suradnica pridavanej lopty
 * @param y
 *            y-ova suradnica pridavanej lopty
 */
public void pridajLoptu(double x, double y) {
        // Vyrobime novu loptu, umiestnime ju do kresliacej plochy a umiestnime
        // ju na poziciu [x, y]
        Lopta novaLopta = new Lopta();
        this.add(novaLopta);
        novaLopta.setPosition(x, y);

        // Vytvorime nove pole lopt, ktore bude o 1 policko vacsie ako
        // predchadzajuce
        Lopta[] noveLopty = new Lopta[this.lopty.length + 1];
        // Skopirujeme referencie na lopty z povodneho pola do noveho
        for (int i = 0; i < this.lopty.length; i++) {
                noveLopty[i] = this.lopty[i];
        }

        // Na posledne policko pola umiestnime referenciu na novovytvorenu loptu
        noveLopty[noveLopty.length - 1] = novaLopta;
        // Zmenime instancnu premennu lopty tak, aby uz nereferencovala povodne
        // pole, ale nove pole, ktore obsahuje navyse aj novovytvorenu loptu
        this.lopty = noveLopty;
}

@Override
protected void onMouseClicked(int x, int y, MouseEvent detail) {
        if (detail.isAltDown()) {
                this.pridajLoptu(x, y);
                 return;
        }

        // Dalsie prikazy tak, ako boli v tejto metode na 5. prednaske
}

import sk.upjs.jpaz2.Turtle;

public class Poliarka extends Turtle {

        /**
         * Vytvori pole cisel zadanej dlzky a naplni ho nahodnymi celymi cislami od
         * 0 po 99.
         *
         * @param dlzka
         *            dlzka vytvaraneho pole
         * @return referencia na novovytvoreny "polovy objekt" (pole) s nahodnymi
         *         cislami
         */
        public int[] nahodnePole(int dlzka) {
                // Ak je dlzka zaporna, tak vratime null
                if (dlzka < 0) {
                        return null;
                }

                // Vyrobime pole pozadovanej dlzky
                int[] vysledok = new int[dlzka];
                // V kazdom policku pola (na kazdom indexe) ulozime nahodne vygenerovane
                // cislo
                for (int i = 0; i < vysledok.length; i++) {
                        vysledok[i] = (int) (Math.random() * 100);
                }

                // Vratime referenciu na vytvorene a uz aj nahodne naplnene pole
                return vysledok;
        }

        /**
         * Vypise pole do konzoly, spravi presne to iste, co:
         * System.out.println(Array.toString(pole))
         *
         * @param pole
         *            referencia na pole cisel, ktore sa ma vypisat
         */
        public void vypisPole(int[] pole) {
                // Ak nemame referenciu na pole, tak koncime hned
                if (pole == null) {
                        return;
                }

                // Vypiseme znak [
                System.out.print("[");

                // Az na posledny prvok pole, vypiseme vsetky cisla poli aj s ciarkou za
                // cislom
                for (int i = 0; i < pole.length - 1; i++) {
                        System.out.print(pole[i] + ", ");
                }

                // Ak pole malo aspon 1 prvok, vypiseme posledne cislo v poli
                if (pole.length >= 1) {
                        System.out.print(pole[pole.length - 1]);
                }

                // Vypiseme ukoncovacie ]
                System.out.println("]");
        }

        /**
         * Vrati, ci su v poli cisel nejake 2 rovnake cisla
         *
         * @param pole
         *            referencia na pole cisel
         * @return true, ak su v poli 2 rovnake cisla
         */
        public boolean rovnakeCisla(int[] pole) {
                // Vyskusame vsetky dvojice indexov
                for (int i = 0; i < pole.length - 1; i++) {
                        // Pre danu hodnotu i, skusame generovat druhy index j ako vsetky
                        // cisla od i+1 po (dlzka pola)-1
                        for (int j = i + 1; j < pole.length; j++) {
                                // Ak su cisla na indexoch i a j rovnake, tak koncime ihned s
                                // true
                                if (pole[i] == pole[j]) {
                                        return true;
                                }
                        }
                }

                // Ak sme sa dostali sem, znamena to, ze ziadne 2 cisla neboli rovnake
                // (inak by sa vykonal if, co by viedlu k ukonceniu vykonavania metody s
                // navratovou hodnotou true). Preto vratime false.
                return false;
        }

        /**
         * Vsetky hodnoty v poli, ktore su vacsia ako zadana hranicna hodnota, znizi
         * na hranicnu hodnotu.
         *
         * @param pole
         *            referencia na pole, ktoreho prvky sa maju "orezat"
         * @param hranica
         *            hranicna hodnota pre orezavanie prvkov pola
         */
        public void orezPole(int[] pole, int hranica) {
                // Specialne osetrime pripad, kedy nam cez parameter pole nedosla ziadna
                // referencia na pole, ale len null.
                if (pole == null) {
                        return;
                }

                // Prechadzame vsetkymi prvkami pole (v i generujeme vsetky indexy) a ak
                // je hodnota na niektorom policku vacsia ako hranicna hodnota v
                // premennej hranica, tak znizime hodnotu tejto premennej na hranicnu
                // hodnotu.
                for (int i = 0; i < pole.length; i++) {
                        if (pole[i] > hranica) {
                                pole[i] = hranica;
                        }
                }
        }

        /**
         * Vrati index najvacsieho prvku v poli
         *
         * @param pole
         *            referencia na pole, v ktorom hladame index maximalnej hodnoty
         */
        public int indexNajvacsieho(int[] pole) {
                // Kandidat na index najvacsieho prvku (na zaciatku predpokladame, ze je
                // to prvok na indexe 0)
                int kandidat = 0;
                // Skusame postupne vsetky prvky, ci nahodou niektory z nich nie je
                // lepsi ako aktualny kandidat
                for (int i = 1; i < pole.length; i++) {
                        // Ak je aktualny prvok lepsi ako kandidat, tak si i zapamatame ako
                        // noveho kandidata
                        if (pole[kandidat] < pole[i]) {
                                kandidat = i;
                        }
                }

                return kandidat;
        }
}

import java.util.Arrays;

import sk.upjs.jpaz2.*;

public class Spustac {

        /**
         * @param args
         */
        public static void main(String[] args) {
                Poliarka zofka = new Poliarka();
                int[] p = zofka.nahodnePole(10);

                System.out.println(Arrays.toString(p));
                zofka.vypisPole(p);

                zofka.orezPole(p, 20);
                zofka.vypisPole(p);
        }
}

import java.awt.Color;
import java.awt.event.MouseEvent;

import sk.upjs.jpaz2.*;


public class Piskvorky extends WinPane {
        /**
         * Cislo hraca (1 alebo 2), ktory je prave na tahu
         */
        private int naTahu = 1;

        /**
         * Referencia na 2D pole, v ktorom si pamatame
         * obsadenost policok
         */
        private int[][] policka;

        /**
         * Pamatame si, ci bezi hra
         */
        private boolean hraBezi = true;

        /**
         * Specialna inicializacna metoda objektov triedy Piskvorky
         */
        public Piskvorky() {
                // Nakreslime mriezku
                this.mriezka();
                // Vytvorime 2D pole. Po vytvoreni je pole naplnene
                // 0-ami (je to defaultna hodnota pre int).
                this.policka = new int[15][15];
        }

        /**
         * Nakresli mriezku 15 x 15
         */
        public void mriezka() {
                // Vytvorime kresliacu korytnacku
                Turtle k = new Turtle();
                // Pridame korytnacku do plochy
                this.add(k);

                // Nakreslime 15 vertikalnych ciar
                for (int i=1; i<16; i++) {
                        k.setPosition(i*20, 0);
                        k.moveTo(i*20, this.getHeight());
                }

                // Nakreslime 15 horizontalnych ciar
                for (int i=1; i<16; i++) {
                        k.setPosition(0, i*20);
                        k.moveTo(this.getWidth(), i*20);
                }

                // Odstranime kresliacu korytnacku z (tejto) plochy
                this.remove(k);
        }

        /**
         * Nakresli bodku zadanej farby na policku v riadku r a stlpci s
         */
        public void bodka(int r, int s, Color c) {
                // Vytvorenie kresliacej korytnacky
                Turtle k = new Turtle();
                // Pridanie korytnacky do (tejto) kresliacej plochy
                this.add(k);

                // Nastavime sa na stred policka a nakreslime bodku
                k.setPosition(s*20 + 10, r*20 + 10);
                k.setFillColor(c);
                k.dot(8);

                // Odstranime korytnacku z kresliacej plochy
                this.remove(k);
        }

        @Override
        protected void onMouseClicked(int x, int y, MouseEvent detail) {
                // Vypocitame si riadok a stlpec policka,
                // do ktoreho sme klikli
                int r = y/20;
                int s = x/20;

                // Ak nebezi hra, tak koncime
                if (this.hraBezi == false)
                        return;

                // Ak je policko obsadene koncime ...
                if (this.policka[r][s] != 0)
                        return;

                // V poli si poznacime, ze obsadzujeme policko
                // (cislom hraca na tahu)
                this.policka[r][s] = this.naTahu;

                // Ak je tahu hrac 1, tak nakreslime cervenu bodku
                // a nastavime, ze na tahu je hrac 2
                // (v opacnom pripade je na tahu hrac 1)
                if (this.naTahu == 1) {
                        this.bodka(r, s, Color.red);
                        this.naTahu = 2;
                } else {
                        this.bodka(r, s, Color.blue);
                        this.naTahu = 1;
                }

                // Po kazdom tahu overime, ci uz nemame vitaza
                this.overHru();
        }

        /**
         * Vrati, ci suradnice policka (riadok, stlpec) su platne
         */
        public boolean jePolicko(int r, int s) {
                return ((r >= 0) && (s >= 0) && (r < 15) && (s < 15));
        }

        /**
         * Spocita pocet rovnakych policok (bez prerusenia), ak sa vyberieme
         * z policka v riadku r a stlpci s, pricom v kazdom kroku
         * zmenime riadok o rPosun a stlpec o sPosun
         */
        public int rovnakychVSmere(int r, int s, int rPosun, int sPosun) {
                // Pocitadlo krokov
                int pocitadlo = 0;
                // Hodnota, ktorej suvisly sled hladame
                int startHodnota = this.policka[r][s];

                // Kym je sme v ploche a na polickach je sledovana hodnota,
                // tak sa hybeme
                while (this.jePolicko(r, s) &&
                                 (this.policka[r][s] == startHodnota)) {
                        // V kazdom kroku posunieme "aktualny riadok a stlpec"
                        r = r + rPosun;
                        s = s + sPosun;
                        // a tiez zvysime pocitadlo krokov
                        pocitadlo++;
                }

                // Dlzka suvisleho sledu je rovna poctu krokov
                return pocitadlo;
        }

        /**
         * Overi, ci v policku v riadku r a stlpci s nezacina vyhernych 5 kamenov v
         * nejakom smere
         */
        public void overPolicko(int r, int s) {
                int[][] posuny = { { 1, -1 }, { 1, 0 }, { 1, 1 }, { 0, 1 } };

                // Ak je policko volne, nie je co riesit a koncime
                if (this.policka[r][s] == 0)
                        return;

                // Skusame kazdy zo smerov "posunutia"
                for (int smer = 0; smer < posuny.length; smer++) {
                        // Spocitame si dlzku suvisleho sledu
                        int vSmere = this.rovnakychVSmere(r, s, posuny[smer][0],
                                                                posuny[smer][1]);

                        // Ak je to viac, ako 5 tak nakreslime ciaru a koncime hru
                        if (vSmere >= 5) {
                                this.spoj(r, s, r + posuny[smer][0] * (vSmere - 1),
                                                s + posuny[smer][1] * (vSmere - 1));
                                this.hraBezi = false;
                        }
                }
        }

        /**
         * Overi, ci nemame vyhernu poziciu
         */
        public void overHru() {
                // Skusame kazde policko
                for (int r = 0; r < 15; r++)
                        for (int s = 0; s < 15; s++)
                                this.overPolicko(r, s);
        }      

        /**
         * Nakresli vyhernu spojovaciu ciaru z policka [r1][s1]
         * do policka [r2][s2]
         */
        public void spoj(int r1, int s1, int r2, int s2) {
                Turtle k = new Turtle();
                this.add(k);

                k.setPenColor(Color.black);
                k.setPenWidth(2);
                k.setPosition(s1*20+10, r1*20+10);
                k.moveTo(s2*20+10, r2*20+10);

                this.remove(k);
        }
}

public class Spustac {

        public static void main(String[] args) {
                Piskvorky hra = new Piskvorky();
        }
}