Podział ArrayList (gra wojna)

Cześć,

Piszę grę karcianą wojnę i się zaciąłem.

Mam stworzoną listę wszystkich kart którą wygenerowałem za pomocą pętli.

ArrayList<Karta> karty = new ArrayList<>();

        for (Ranga value : Ranga.values()) {
            for (Kolor kolor : Kolor.values()) {
                Karta karta1 = new Karta(kolor, value);
                karty.add(karta1);
            }
        }

Wyświetlam ją sobie sobie, pokazuje mi wielkość tablicy i na końcu ją mieszam:

System.out.println(karty);
        System.out.println(karty.size());

        Collections.shuffle(karty);

Przykład klasy z rangą:

public enum  Ranga {
    DZIEWIEC(1), DYCHA(2), JOPEK(3), DAMA(4), KROL(5), AS(6);

    private int sila;

    Ranga(int sila) {
        this.sila = sila;
    }

    public int getSila() {
        return sila;
    }
}

Wszystko się zgadza do tej pory ale, nie mam pojęcia jak mam podzielić moją wymieszaną listę na dwóch graczy.
Z góry dzięki za podpowiedzi.

Wykorzystaj metodę sublist. Zalecam też stosowanie interfejsów zamiast konkretnych typów, w tym przypadku List zamiast ArrayList

@Aleksander32: Ok, załapałem mam nadzieję że pójdzie dalej. dzięki.

Collections.shuffle(karty);
        System.out.println();

        List<Karta> playerOne;
        List<Karta> playerTwo;
        playerOne = karty.subList(0, 11);
        playerTwo = karty.subList(12, 23);

Mam jeszcze jedno pytanie. Nie wiem jak podliczyć punkty z wojny aktualnie to wygląda tak:

public class Wojna {

    private int winPlayeOne0 = 0;
    private int winPlayeTwo = 0;
    private int warPoint =0;



    public void war(Karta karta, Karta karta2) {

        if (karta.getSila() > karta2.getSila()) {
            winPlayeOne0++;
            System.out.println("Wygrała gracz 1");
        } else if (karta.getSila() < karta2.getSila()) {
            winPlayeTwo++;
            System.out.println("Wygrał gracz 2");
        } else {
            System.out.println("Wojna");
                warPoint++;
            }
        }

    public int getWarPoint() {
        return warPoint;
    }

    public int getWinPlayeOne0() { return winPlayeOne0; }

    public int getWinPlayeTwo() { return winPlayeTwo; }

    @Override
    public String toString() {
        return "Wojna{" +
                "winPlayeOne0=" + winPlayeOne0 +
                ", winPlayeTwo=" + winPlayeTwo +
                '}';
    }
}

Super to działa jak nie ma wojny. Main działa tak:

 Wojna wojna = new Wojna();
        int runda =0;
        do{
            runda++;
            System.out.println("Pierwszy gracz wyciągnął: " + playerOne.get(runda));
            System.out.println("Drugi gracz wyciągnął: " + playerTwo.get(runda));
            wojna.war(playerOne.get(runda),playerTwo.get(runda) );
            System.out.println();


        }while (runda<=10);

Jakby ktoś podrzucił pomysł jak to ugryź to z góry dzięki. Inkrementacja "warpoint" to pozostałości po moim kombinowaniu :)

Przekaz do wojna.war graczy a nie ich karty a w tym else ostatnim wywolaj funkcje jeszcze raz (rekurencyjnie) z nastepna karta, bedziesz musial przeniesc liczbe rund do Wojna zeby tam w odpowiednim momencie przerwac gre (np jesli 10 razy z rzedu bedzie wojna).

Jako rozwiniecie cwiczenia zaproponowalbym obsluzyc sytuacje gdzie N graczy ma mozliwosc grania, a liczba rund nie jest na sztywno 10, tylko np tez jest losowana a pozniej gra trwa dopoki runda < taWylosowanaLiczbaRund lub dopoki nie skoncza sie karty. Mozna tez dodac mozliwosc grania N taliami

@pedegie: Nie mam pojęcia jak to wykonać :D
Aktualnie nie mam klasy Gracz/Player mój podział na karty playerOne i playerTwo to zapis z maina:

var playerOne = karty.subList(0, 12);    
 var playerTwo = karty.subList(12, 24); 

Rekurencje zrozumiałem w ten sposób że muszę przekazać do metody war argument int (nie może być void)
Mój podział na playerOne i playerTwo się nie nadaję...

Dodam jeszcze że moja klasa Karta ma przekazane zmienne enumy Ranga i Kolor - jeżeli przekaże do metody war inne argumenty to mi się to wywali logika samej wojny ;/

public class Karta {
    private Kolor kolor;
    private Ranga ranga;

    public Karta(Kolor kolor, Ranga ranga) {
        this.kolor = kolor;
        this.ranga = ranga;
    }

    public int getSila() {
        return ranga.getSila();
    }

    @Override
    public String toString() {
        return "Karta{" +
                "kolor=" + kolor +
                ", ranga=" + ranga +
                '}';
    }
}

ehhh będę walczył... z góry dzięki za dalszą pomoc.

No u Ciebie Twoi gracze to te sublisty powiedzmy. Moze sprobuj tak zaczac:

War war = new War(playerOne, playerTwo);
war.play();

rekurencyjnie mialem na mysli:

    public void war(Karta karta, Karta karta2) {

        if (karta.getSila() > karta2.getSila()) {
            winPlayeOne0++;
            System.out.println("Wygrała gracz 1");
        } else if (karta.getSila() < karta2.getSila()) {
            winPlayeTwo++;
            System.out.println("Wygrał gracz 2");
        } else {
            System.out.println("Wojna");
                warPoint++;
                runda++;
                war(playerOne.get(runda), playerTwo.get(runda));
            }
        }

Jakos tak, dlatego musisz te zmienne przekazac do klasy Wojna, czyli runde i playerow (sublisty) i w klasie Wojna wolac petle. Powinienes tez na poczatku tej metody sprawdzic czy to nie byla juz ostatnia runda / karta bo Ci sie wywali program jesli bedzie runda > sublist.size. Wtedy mozesz calkiem z tej petli zrezygnowac na rzecz rekurencji

Dobra cos takiego na szybko naklepalem bez rekurencji. Mozesz to rozwinac o tamte punkty dodatkowe co pisalem to sie czegos nauczysz ;p

public class Main
{
    public static void main(String[] args)
    {
        List<Integer> playerOne = new ArrayList<>(Arrays.asList(1,5,2,3,4,1,3,1,32,1,3,5,6,3));
        List<Integer> playerTwo = new ArrayList<>(Arrays.asList(1,5,2,3,4,1,3,5,32,1,3,5,1,3));
        War war = new War(playerOne, playerTwo);
        war.play();
    }


}

class War {

    private int round;
    private int warPoint;

    private final List<Integer> playerOne;
    private int playerOnePoints;
    private final List<Integer> playerTwo;
    private int playerTwoPoints;

    public War(List<Integer> playerOne, List<Integer> playerTwo)
    {
        this. playerOne = playerOne;
        this.playerTwo = playerTwo;
    }

    public void play()
    {
        while(round < 10)
        {
            playRound(round);
            round++;
        }

        System.out.println("Print results");
    }

    private void playRound(int round)
    {
        Integer playerOneCard = playerOne.get(round);
        Integer playerTwoCard = playerTwo.get(round);

        if(playerOneCard > playerTwoCard)
            playerOnePoints++;
        else if(playerOneCard < playerTwoCard)
            playerTwoPoints++;
        else
            warPoint++;
    }
}