testing

import greenfoot.*;

public class People extends Actor
{
    private int infectiousState;
    
    public People() {
        this(false);
    }
    
    public People(boolean state) {
        setInfectedState(state);
    }
    
    public void act() {
        runInfectionTimer();
        moveRandom();
        spreadInfection();
    }
    
    private void runInfectionTimer() {
        if (isInfected() && ++infectiousState > 200) setImmune(true);
    }
    
    private void moveRandom() {
        move(4);
        if (Greenfoot.getRandomNumber(100) < 20) turn(Greenfoot.getRandomNumber(61)-30);
        if (isAtEdge()) turn(180);
    }
    
    private void spreadInfection() {
        if (!isInfected()) return;
        for (People p : getIntersectingObjects(People.class)) p.setInfected(true);
    }
    
    public boolean isNormal() {
        return infectiousState == 0;
    }
    
    public boolean isImmune() {
        return infectiousState == -1;
    }
    
    public boolean isInfected() {
        return infectiousState > 0;
    }
    
    public void setImmune(boolean newState) {
        if (newState == true) {
            infectiousState = -1;
            setImage("immune.png");
        }
        else setInfectedState(false);
    }
    
    public void setInfectedState(boolean newState) {
        if (isImmune()) return;
        if (newState == true) {
            if (isInfected()) return;
            infectiousState++;
            setImage("infected.png");
        }
        else {
            infectiousState = 0;
            setImage("normal.png");
        }
    }
}

People infected = new People(true);

addObject(new People(true), ...etc.

addObject(new People(), ...etc

addObject(new People(false), ... etc

public MyWorld() {
    super(800, 600, 1);
    for (int i=0; i<51; i++) {
        People p = new People(i == 50);
        int x = Greenfoot.getRandomNumber(getWidth());
        int y = Greenfoot.getRandomNumber(getHeight());
        addObject(p, x, y);
    }
    addObject(new Ambulance(), 0, 0);
}

/**
 * Rekap skor submission peserta CodeClash menggunakan ragged array.
 * skorSubmission[i].length = jumlah submission peserta ke-i (bisa berbeda
 * antar peserta, termasuk 0 bila belum pernah submit).
 */
public class Leaderboard {

    private String[] namaPeserta;
    private int[][] skorSubmission;

    public Leaderboard(String[] namaPeserta, int[][] skorSubmission) {
        this.namaPeserta = namaPeserta;
        this.skorSubmission = skorSubmission;
    }

    /** Tugas Anda (b): jumlahkan seluruh skor submission peserta ke-i. */
    public int totalSkor(int pesertaIndex) {
        // Ingat: SELALU pakai skorSubmission[pesertaIndex].length untuk
        // iterasi, jangan asumsikan semua peserta punya jumlah submission
        // yang sama.
        int totalSkor = 0;
        for (int i = 0; i < skorSubmission[pesertaIndex].length; i++){
            totalSkor += skorSubmission[pesertaIndex][i];  
        }
        return totalSkor;        
    }

    /**
     * Tugas Anda (b): rata-rata skor submission peserta ke-i.
     * Kembalikan 0 bila peserta belum pernah submit.
     */
    public double rataRataSkor(int pesertaIndex) {
        double rataRata = 0;
        if (skorSubmission[pesertaIndex].length == 0){
            return rataRata;
        } else {
            rataRata = (double) totalSkor(pesertaIndex) / skorSubmission[pesertaIndex].length;
            return rataRata;
        }
    }

    /**
     * Tugas Anda (c): index submission dengan skor tertinggi milik peserta
     * ke-i. Kembalikan -1 bila peserta belum pernah submit.
     */
    public int submissionTerbaik(int pesertaIndex) {
        if (skorSubmission[pesertaIndex].length == 0) {
            return -1;
        }
        int maxSkor = skorSubmission[pesertaIndex][0];
        int indexMax = 0;
        for (int i = 1; i < skorSubmission[pesertaIndex].length; i++) {
            if (skorSubmission[pesertaIndex][i] > maxSkor) {
                maxSkor = skorSubmission[pesertaIndex][i];
                indexMax = i;
            }
        }
        return indexMax;
    }

    /**
     * Tugas Anda (c): index peserta dengan totalSkor() tertinggi se-leaderboard.
     * Bila seri, kembalikan index terkecil.
     */
    public int pesertaSkorTertinggi() {
        int maxTotalSkor = totalSkor(0);
        int indexMax = 0;
        for (int i = 1; i < jumlahPeserta(); i++) {
            int totalSkor = totalSkor(i);
            if (totalSkor > maxTotalSkor) {
                maxTotalSkor = totalSkor;
                indexMax = i;
            }
        }
        return indexMax;
    }

    public String getNamaPeserta(int index) {
        return namaPeserta[index];
    }

    public int jumlahPeserta() {
        return namaPeserta.length;
    }
}

/** Tugas Anda (b): valid bila nomorKartu 16 digit angka DAN belum expired. */
public class KartuKredit implements MetodePembayaran {

    private String nomorKartu;
    private boolean sudahExpired;

    public KartuKredit(String nomorKartu, boolean sudahExpired) {
        // TODO: inisialisasi field.
        this.nomorKartu = nomorKartu;
        this.sudahExpired = sudahExpired;
    }

    @Override
    public String getNamaMetode() {
        return "Kartu Kredit";
    }

    @Override
    public boolean validasi() {
        // TODO (b): valid bila nomorKartu terdiri dari tepat 16 digit angka
        // DAN sudahExpired bernilai false.
        return nomorKartu.matches("\\d{16}") && !sudahExpired;
    }

    @Override
    public StatusPembayaran prosesBayar(double nominal) {
        // TODO (b): bila !validasi() atau nominal <= 0 -> GAGAL.
        // Bila valid dan nominal > 0 -> SUKSES.
        if (!validasi() || nominal<= 0){
            return StatusPembayaran.GAGAL;
        } else {
            return StatusPembayaran.SUKSES;
        }
    }
}

import java.util.ArrayList;
import java.util.List;

/** Tugas Anda (c): implementasikan Repository<Reservasi>. */
public class ReservasiRepository implements Repository<Reservasi> {

    private List<Reservasi> items = new ArrayList<>();

    @Override
    public void save(Reservasi item) {
        // TODO (c): simpan item ke dalam items.
        items.add(item);
    }

    @Override
    public Reservasi findById(String id) {
        // TODO (c): cari dan kembalikan Reservasi dengan id yang cocok,
        // atau null bila tidak ditemukan.
        for (Reservasi reservasi : items){
            if (reservasi.getId().equals(id)){
                return reservasi;
            }
        }
        return null;
    }

    @Override
    public List<Reservasi> getAll() {
        // TODO (c): kembalikan seluruh isi items.
        return new ArrayList<>(items);
    }
}

/** Mengorkestrasi pembuatan reservasi: validasi, bayar, simpan. */
public class ReservasiService {

    private ReservasiRepository repository;
    private int counter = 0;

    public ReservasiService(ReservasiRepository repository) {
        this.repository = repository;
    }

    /**
     * Tugas Anda (d): validasi metode pembayaran, proses pembayaran, set
     * status reservasi sesuai hasil prosesBayar(), simpan reservasi ke
     * repository, lalu kembalikan objek Reservasi tersebut (status sudah
     * final: SUKSES atau GAGAL).
     */
    public Reservasi buatReservasi(String namaPemesan, double totalHarga, MetodePembayaran metode) {
        if (!metode.validasi()) {
            Reservasi reservasi = new Reservasi(buatId(), namaPemesan, totalHarga, metode);
            reservasi.setStatus(StatusPembayaran.GAGAL);
            repository.save(reservasi);
            return reservasi;
        }
            StatusPembayaran status = metode.prosesBayar(totalHarga);
            Reservasi reservasi = new Reservasi(buatId(), namaPemesan, totalHarga, metode);
            reservasi.setStatus(status);
            repository.save(reservasi);
            return reservasi;
    }

    /** Helper pembuat ID reservasi, silakan dipakai di buatReservasi(). */
    protected String buatId() {
        counter++;
        return "RSV-" + System.currentTimeMillis() + "-" + counter;
    }
}

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * Memproses file pendaftaran peserta HackFest: membaca, memvalidasi, dan
 * menulis laporan. Ini adalah file utama yang Anda kerjakan.
 */
public class PendaftaranProcessor {

    private List<Peserta> pesertaDiterima = new ArrayList<>();

    public List<Peserta> getPesertaDiterima() {
        return pesertaDiterima;
    }

    /**
     * Tugas Anda (a, b, c): baca namaFile baris demi baris. Format tiap
     * baris: Nama,Umur,Kategori,BiayaPendaftaran
     *
     * - (a) Tangani FileNotFoundException: cetak "File peserta tidak
     *   ditemukan!", program tidak boleh crash.
     * - (b) Tangani NumberFormatException saat parsing Umur/BiayaPendaftaran:
     *   cetak "Data tidak valid pada baris ke-N (Nama), baris dilewati."
     *   lalu lanjut ke baris berikutnya.
     * - (c) Validasi umur (17-25); jika di luar rentang, lempar dan tangkap
     *   UmurTidakValidException, cetak "Pendaftaran [Nama] ditolak: umur
     *   tidak memenuhi syarat (17-25 tahun).", baris dilewati.
     * - Baris yang valid ditambahkan ke pesertaDiterima.
     */
    public void prosesFile(String namaFile) {
        try {
            Scanner scanner = new Scanner(new File(namaFile));
            int baris = 1;

            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();

                try {
                    String[] data = line.split(",");

                    String nama = data[0];
                    int umur = Integer.parseInt(data[1]);
                    String kategori = data[2];
                    double biaya = Double.parseDouble(data[3]);

                    if (umur < 17 || umur > 25) {
                        throw new UmurTidakValidException(
                                "Pendaftaran " + nama +
                                " ditolak: umur tidak memenuhi syarat (17-25 tahun).");
                    }

                    pesertaDiterima.add(
                            new Peserta(nama, umur, kategori, biaya)
                    );

                } catch (NumberFormatException e) {
                    String nama = line.split(",")[0];
                    System.out.println(
                            "Data tidak valid pada baris ke-" +
                            baris + " (" + nama + "), baris dilewati.");
                } catch (UmurTidakValidException e) {
                    System.out.println(e.getMessage());
                }

                baris++;
            }

            scanner.close();

        } catch (FileNotFoundException e) {
            System.out.println("File peserta tidak ditemukan!");
        }

    }

    /**
     * Tugas Anda (d): tulis file namaFileOutput berisi daftar nama peserta
     * pada pesertaDiterima beserta total biaya pendaftaran yang terkumpul.
     */
    public void tulisLaporan(String namaFileOutput) {
        try {
            PrintWriter writer = new PrintWriter(new FileWriter(namaFileOutput));

            for (Peserta p : pesertaDiterima) {
                writer.println(p.getNama());
            }

            writer.println("Total Biaya: " + getTotalBiaya());

            writer.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /** Total biaya pendaftaran dari seluruh peserta yang diterima. */
    public double getTotalBiaya() {
        double total = 0;

        for (Peserta p : pesertaDiterima) {
            total += p.getBiayaPendaftaran();
        }

        return total;
    }
}

import java.util.ArrayList;
import java.util.List;

/**
 * Tugas Anda (b): generic class yang hanya boleh menyimpan SATU jenis
 * barang (dijamin compiler lewat <T extends Barang>).
 */
public class Gudang<T extends Barang> {

    private List<T> daftarBarang = new ArrayList<>();

    public void tambah(T item) {
        // TODO (b): tambahkan item ke daftarBarang.
        daftarBarang.add(item);
    }

    public T get(int index) {
        // TODO (b): kembalikan barang pada index tersebut.
        return daftarBarang.get(index);
    }

    /** Total harga seluruh barang di gudang ini. */
    public double totalNilai() {
        // TODO (b): jumlahkan getHarga() seluruh isi daftarBarang.
        double total = 0;

    for (T barang : daftarBarang) {
        total += barang.getHarga();
        }

        return total;
    }

    public int jumlahBarang() {
        return daftarBarang.size();
    }
}

import java.util.Collections;
import java.util.List;

/** Kumpulan generic method utility yang bekerja di atas Gudang jenis apa pun. */
public class UtilGudang {

    /**
     * Tugas Anda (c): generic method dengan upper bound. Kembalikan barang
     * dengan harga tertinggi dari daftar. Asumsikan daftar tidak kosong.
     */
    public static <T extends Barang> T cariTermahal(List<T> daftar) {
        T termahal = daftar.get(0);

        for (T barang : daftar) {
            if (barang.getHarga() > termahal.getHarga()) {
            termahal = barang;
            }
        }

        return termahal;
    }

    /**
     * Tugas Anda (c): generic method dengan wildcard. Jumlahkan totalNilai()
     * dari SELURUH gudang pada daftarGudang, walaupun tiap gudang berisi
     * jenis barang yang berbeda-beda (Elektronik, Fashion, dst).
     */
    public static double totalNilaiSemuaGudang(List<Gudang<? extends Barang>> daftarGudang) {
        double total = 0;

        for (Gudang<? extends Barang> gudang : daftarGudang) {
            total += gudang.totalNilai();
        }

        return total;
    }

    /**
     * (Bonus, Tugas d) generic method dengan multiple bound: T harus berupa
     * Barang SEKALIGUS Comparable&lt;T&gt;. Urutkan daftar secara ascending
     * memakai Comparable-nya sendiri (mis. Collections.sort).
     */
    public static <T extends Barang & Comparable<T>> void urutkanNaik(List<T> daftar) {
        Collections.sort(daftar);
    }
}

/**
 * Tugas Anda (a): implementasikan Barang dan Comparable<Elektronik>
 * (compareTo berdasarkan harga, ascending).
 */
public class Elektronik implements Barang, Comparable<Elektronik> {

    private String nama;
    private double harga;
    private double berat;

    public Elektronik(String nama, double harga, double berat) {
        // TODO (a): inisialisasi field.
        this.nama = nama;
        this.harga = harga;
        this.berat = berat;
    }

    @Override
    public String getNama() {
        return nama;
    }

    @Override
    public double getHarga() {
        return harga;
    }

    @Override
    public double getBerat() {
        return berat;
    }

    @Override
    public int compareTo(Elektronik lainnya) {
        // TODO (a): bandingkan berdasarkan harga (ascending).
        return Double.compare(this.harga, lainnya.harga);
    }

    @Override
    public String toString() {
        return getNama() + " (Rp" + getHarga() + ")";
    }
}