Code4life cg-brutaltester referee

Referee.java

import java.awt.Point;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Properties;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.StringJoiner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class Referee extends MultiReferee {

    public static int LEAGUE_LEVEL = 2; // 0, 1 or 2

    public static final int EV_NEW_SAMPLE = 0;
    public static final int EV_TAKE_SAMPLE = 1;
    public static final int EV_STORE_SAMPLE = 2;
    public static final int EV_TAKE_RESOURCE = 3;
    public static final int EV_DIAGNOSE = 4;
    public static final int EV_PRODUCE = 5;
    public static final int EV_CLONE_INITAL_SAMPLE = 6;
    public static final int[] RESOURCE_PER_TYPE_BY_LEAGUE_LEVEL = {99, 99, 6};
    public static final int[] SCIENCE_PROJECTS_BY_LEAGUE_LEVEL = {0, 0, 3};
    public static final int[] INIT_DIAGNOSED_SAMPLES_BY_LEAGUE_LEVEL = {50, 0, 0};
    public static final int MAX_STORAGE = 10;
    public static final int MAX_TRAY = 3;
    public static final int SAMPLE_RANK_COUNT = 3;
    public static final int SCIENCE_PROJECT_VALUE = 30;
    public static final int MAX_SCORE = 170;

    enum MoleculeType {
        A(0), B(1), C(2), D(3), E(4);

        int index;

        private MoleculeType(int index) {
            this.index = index;
        }
    }

    enum Bound {
        TO_DIAGNOSIS, FROM_SAMPLES, FROM_DIAGNOSIS
    }

    enum Module {
        SAMPLES, DIAGNOSIS, MOLECULES, LABORATORY, START_POS
    }

    static class PlayerData {
        int[] storage, expertise;
        boolean dead, attemptConnection, moved;
        int eta, score, deadAt, index;
        String message, connectionData;
        List<Sample> tray;
        Module from, target;

        public PlayerData(int index) {
            int capacity = MoleculeType.values().length;
            from = Module.START_POS;
            target = Module.START_POS;
            eta = 0;
            storage = new int[capacity];
            expertise = new int[capacity];
            this.index = index;
            score = 0;
            tray = new ArrayList<>(3);
        }

        public void die(int round) {
            if (!dead) {
                dead = true;
                deadAt = round;
                score = -1;
            }
        }

        public void reset() {
            message = null;
            attemptConnection = false;
            moved = false;
            connectionData = null;
        }

        public void setMessage(String message) {
            this.message = message;
            if (message != null && message.length() > 19) {
                this.message = message.substring(0, 17) + "...";
            }
        }

        public boolean isMoving() {
            return eta > 0;
        }
    }

    static class Sample {
        public static int ENTITY_COUNT = 0;

        MoleculeType expertise;
        int life;
        int[] cost;
        int id, rank;
        private boolean discovered;
        PlayerData discoveredBy;

        public Sample(int[] cost, int life, MoleculeType gain) {
            this.expertise = gain;
            this.life = life;
            this.cost = cost;
        }

        public void setDiscovered(boolean discovered) {
            this.discovered = discovered;

        }

        public boolean isDiscovered() {
            return discovered;

        }

        public Sample clone() {
            return new Sample(cost, life, expertise);
        }

        public String getGainChar() {
            return (expertise == null) ? "0" : expertise.name();
        }
    }

    static class ScienceProject {
        int[] cost;
        int index;

        public ScienceProject(int[] cost) {
            this.cost = cost;
        }
    }

    static class Diagnosis {
        PlayerData player;
        Sample sample;

        public Diagnosis(PlayerData player, Sample sample) {
            this.player = player;
            this.sample = sample;
        }
    }

    static class Translatable {
        String code;
        Object[] values;

        public Translatable(String code, Object... values) {
            this.code = code;
            this.values = values;
        }
    }

    static abstract class Transfer {
        PlayerData player;

        public Transfer(PlayerData player) {
            this.player = player;
        }

        public abstract void apply(Referee refere);

        public abstract Translatable getSummary();
    }

    static class ProductionTransfer extends Transfer {
        Sample sample;

        public ProductionTransfer(PlayerData player, Sample sample) {
            super(player);
            this.sample = sample;
        }

        @Override
        public void apply(Referee referee) {
            player.tray.remove(sample);

            for (int i = 0; i < MoleculeType.values().length; ++i) {
                int toPay = Math.max(0, sample.cost[i] - player.expertise[i]);
                player.storage[i] -= toPay;
                MoleculeType type = MoleculeType.values()[i];
                referee.molecules.put(type, referee.molecules.get(type) + toPay);
            }

            player.score += sample.life;
            if (sample.expertise != null) {
                player.expertise[sample.expertise.index]++;
            }
        }

        @Override
        public Translatable getSummary() {
            if (sample.expertise == null) {
                return new Translatable("productionNoGain", player.index, sample.id, sample.life);
            }
            return new Translatable("production", player.index, sample.id, sample.life, sample.expertise.name());
        }
    }

    static class SampleTransfer extends Transfer {
        Sample sample, clone;
        Bound bound;

        public SampleTransfer(PlayerData player, Sample sample, Bound bound) {
            super(player);
            this.sample = sample;
            this.bound = bound;
        }

        @Override
        public void apply(Referee referee) {
            if (bound.equals(Bound.TO_DIAGNOSIS)) {
                player.tray.remove(sample);
                if (referee.storedSamples.stream().noneMatch(stored -> stored.equals(sample))) {
                    referee.storedSamples.add(sample);
                }

            } else if (bound.equals(Bound.FROM_SAMPLES)) {
                player.tray.add(sample);
            } else if (bound.equals(Bound.FROM_DIAGNOSIS)) {
                if (clone == null) {
                    player.tray.add(sample);
                    referee.storedSamples.remove(sample);
                } else {
                    player.tray.add(clone);
                }
            }
        }

        @Override
        public Translatable getSummary() {
            if (bound.equals(Bound.TO_DIAGNOSIS)) {
                return new Translatable("upload", player.index, sample.id);
            } else if (bound.equals(Bound.FROM_SAMPLES)) {
                return new Translatable("newSample", player.index, sample.id);
            } else {
                return new Translatable("download", player.index, sample.id);
            }
        }

        public void setClone(Sample clonedSample) {
            this.clone = clonedSample;
        }

    }

    static class ProjectCompletion {
        PlayerData player;
        ScienceProject project;

        public ProjectCompletion(PlayerData player, ScienceProject project) {
            this.player = player;
            this.project = project;
        }
    }

    static class ResourceTransfer extends Transfer {
        MoleculeType resourceType;

        public ResourceTransfer(PlayerData player, MoleculeType type) {
            super(player);
            this.resourceType = type;
        }

        @Override
        public void apply(Referee referee) {
            player.storage[resourceType.index]++;
            referee.molecules.put(resourceType, referee.molecules.get(resourceType) - 1);
        }

        @Override
        public Translatable getSummary() {
            return new Translatable("takeMolecule", player.index, resourceType.name());
        }
    }

    static class ModulePair {
        HashSet<Module> set;

        public ModulePair(Module a, Module b) {
            set = new HashSet<>();
            set.add(a);
            set.add(b);
        }

        @Override
        public int hashCode() {
            return set.hashCode();
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            ModulePair other = (ModulePair) obj;
            return set.equals(other.set);
        }
    }

    static final Pattern PLAYER_MOVE_PATTERN = Pattern.compile("^GOTO\\s+(?<module>LABORATORY|DIAGNOSIS|MOLECULES|SAMPLES)(?:\\s+)?(?:\\s+(?<message>.+))?", Pattern.CASE_INSENSITIVE);
    static final Pattern PLAYER_WAIT_PATTERN = Pattern.compile("^WAIT(?:\\s+)?(?:\\s+(?<message>.+))?", Pattern.CASE_INSENSITIVE);
    static final Pattern PLAYER_USE_PATTERN = Pattern.compile("^CONNECT(?:\\s+(?<data>[ABCDE]|(?:-?\\d+)))?(?:\\s+)?(?:\\s+(?<message>.+))?$", Pattern.CASE_INSENSITIVE);
    static final String[] EXPECTED_BY_LEAGUE_LEVEL = {"GOTO LABORATORY|DIAGNOSIS|MOLECULES | CONNECT data", "GOTO LABORATORY|DIAGNOSIS|MOLECULES|SAMPLES | CONNECT data", "GOTO LABORATORY|DIAGNOSIS|MOLECULES|SAMPLES | CONNECT data"};

    private List<PlayerData> players;
    private List<Transfer> transfers;
    private Map<Sample, SampleTransfer> cloudRequests;
    private List<Diagnosis> diagnoses;
    private List<ProjectCompletion> projectCompletions;
    private Random random;
    private List<LinkedList<Sample>> samplePool;
    List<Sample> storedSamples;
    List<ScienceProject> scienceProjects;
    private long seed;
    Map<MoleculeType, Integer> molecules;
    Map<ModulePair, Integer> distances;

    public Referee(InputStream is, PrintStream out, PrintStream err) throws IOException {
        super(is, out, err);
    }

    @Override
    protected void initReferee(int playerCount, Properties prop) throws InvalidFormatException {
        seed = Long.valueOf(prop.getProperty("seed", String.valueOf(new Random(System.currentTimeMillis()).nextLong())));

        random = new Random(seed);

        // map
        initMap();

        // players
        players = new ArrayList<PlayerData>();
        for (int i = 0; i < playerCount; ++i) {
            players.add(i, new PlayerData(i));
        }

        // resources
        molecules = new HashMap<>();
        for (MoleculeType type : MoleculeType.values()) {
            molecules.put(type, RESOURCE_PER_TYPE_BY_LEAGUE_LEVEL[LEAGUE_LEVEL]);
        }

        // samples
        initSamplePool();
        storedSamples = new LinkedList<>();

        // science
        initScienceProjects();

        // diagnosis
        initDiagnonisModule();

        transfers = new LinkedList<>();
        cloudRequests = new HashMap<>();
        diagnoses = new LinkedList<>();
        projectCompletions = new LinkedList<>();

    }

    private void initScienceProjects() {
        LinkedList<ScienceProject> scienceProjectPool;
        scienceProjectPool = new LinkedList<>();
        scienceProjectPool.add(new ScienceProject(new int[]{3, 3, 0, 0, 3}));
        scienceProjectPool.add(new ScienceProject(new int[]{0, 3, 3, 3, 0}));
        scienceProjectPool.add(new ScienceProject(new int[]{3, 0, 0, 3, 3}));
        scienceProjectPool.add(new ScienceProject(new int[]{0, 0, 4, 4, 0}));
        scienceProjectPool.add(new ScienceProject(new int[]{0, 4, 4, 0, 0}));
        scienceProjectPool.add(new ScienceProject(new int[]{0, 0, 0, 4, 4}));
        scienceProjectPool.add(new ScienceProject(new int[]{4, 0, 0, 0, 4}));
        scienceProjectPool.add(new ScienceProject(new int[]{3, 3, 3, 0, 0}));
        scienceProjectPool.add(new ScienceProject(new int[]{0, 0, 3, 3, 3}));
        scienceProjectPool.add(new ScienceProject(new int[]{4, 4, 0, 0, 0}));
        Collections.shuffle(scienceProjectPool, random);

        scienceProjects = new ArrayList<>(SCIENCE_PROJECTS_BY_LEAGUE_LEVEL[LEAGUE_LEVEL]);
        for (int i = 0; i < SCIENCE_PROJECTS_BY_LEAGUE_LEVEL[LEAGUE_LEVEL]; ++i) {
            ScienceProject project = scienceProjectPool.pop();
            project.index = i;
            scienceProjects.add(project);
        }
    }

    private void initSamplePool() {
        samplePool = new ArrayList<LinkedList<Sample>>(SAMPLE_RANK_COUNT);
        for (int rank = 0; rank < SAMPLE_RANK_COUNT; ++rank) {
            LinkedList<Sample> cells = new LinkedList<Sample>();
            samplePool.add(cells);
        }
        samplePool.get(0).add(new Sample(new int[]{0, 3, 0, 0, 0}, 01, MoleculeType.A));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 0, 2, 1}, 01, MoleculeType.A));
        samplePool.get(0).add(new Sample(new int[]{0, 1, 1, 1, 1}, 01, MoleculeType.A));
        samplePool.get(0).add(new Sample(new int[]{0, 2, 0, 0, 2}, 01, MoleculeType.A));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 4, 0, 0}, 10, MoleculeType.A));
        samplePool.get(0).add(new Sample(new int[]{0, 1, 2, 1, 1}, 01, MoleculeType.A));
        samplePool.get(0).add(new Sample(new int[]{0, 2, 2, 0, 1}, 01, MoleculeType.A));
        samplePool.get(0).add(new Sample(new int[]{3, 1, 0, 0, 1}, 01, MoleculeType.A));
        samplePool.get(0).add(new Sample(new int[]{1, 0, 0, 0, 2}, 01, MoleculeType.B));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 0, 0, 3}, 01, MoleculeType.B));
        samplePool.get(0).add(new Sample(new int[]{1, 0, 1, 1, 1}, 01, MoleculeType.B));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 2, 0, 2}, 01, MoleculeType.B));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 0, 4, 0}, 10, MoleculeType.B));
        samplePool.get(0).add(new Sample(new int[]{1, 0, 1, 2, 1}, 01, MoleculeType.B));
        samplePool.get(0).add(new Sample(new int[]{1, 0, 2, 2, 0}, 01, MoleculeType.B));
        samplePool.get(0).add(new Sample(new int[]{0, 1, 3, 1, 0}, 01, MoleculeType.B));
        samplePool.get(0).add(new Sample(new int[]{2, 1, 0, 0, 0}, 01, MoleculeType.C));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 0, 3, 0}, 01, MoleculeType.C));
        samplePool.get(0).add(new Sample(new int[]{1, 1, 0, 1, 1}, 01, MoleculeType.C));
        samplePool.get(0).add(new Sample(new int[]{0, 2, 0, 2, 0}, 01, MoleculeType.C));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 0, 0, 4}, 10, MoleculeType.C));
        samplePool.get(0).add(new Sample(new int[]{1, 1, 0, 1, 2}, 01, MoleculeType.C));
        samplePool.get(0).add(new Sample(new int[]{0, 1, 0, 2, 2}, 01, MoleculeType.C));
        samplePool.get(0).add(new Sample(new int[]{1, 3, 1, 0, 0}, 01, MoleculeType.C));
        samplePool.get(0).add(new Sample(new int[]{0, 2, 1, 0, 0}, 01, MoleculeType.D));
        samplePool.get(0).add(new Sample(new int[]{3, 0, 0, 0, 0}, 01, MoleculeType.D));
        samplePool.get(0).add(new Sample(new int[]{1, 1, 1, 0, 1}, 01, MoleculeType.D));
        samplePool.get(0).add(new Sample(new int[]{2, 0, 0, 2, 0}, 01, MoleculeType.D));
        samplePool.get(0).add(new Sample(new int[]{4, 0, 0, 0, 0}, 10, MoleculeType.D));
        samplePool.get(0).add(new Sample(new int[]{2, 1, 1, 0, 1}, 01, MoleculeType.D));
        samplePool.get(0).add(new Sample(new int[]{2, 0, 1, 0, 2}, 01, MoleculeType.D));
        samplePool.get(0).add(new Sample(new int[]{1, 0, 0, 1, 3}, 01, MoleculeType.D));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 2, 1, 0}, 01, MoleculeType.E));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 3, 0, 0}, 01, MoleculeType.E));
        samplePool.get(0).add(new Sample(new int[]{1, 1, 1, 1, 0}, 01, MoleculeType.E));
        samplePool.get(0).add(new Sample(new int[]{2, 0, 2, 0, 0}, 01, MoleculeType.E));
        samplePool.get(0).add(new Sample(new int[]{0, 4, 0, 0, 0}, 10, MoleculeType.E));
        samplePool.get(0).add(new Sample(new int[]{1, 2, 1, 1, 0}, 01, MoleculeType.E));
        samplePool.get(0).add(new Sample(new int[]{2, 2, 0, 1, 0}, 01, MoleculeType.E));
        samplePool.get(0).add(new Sample(new int[]{0, 0, 1, 3, 1}, 01, MoleculeType.E));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 0, 5, 0}, 20, MoleculeType.A));
        samplePool.get(1).add(new Sample(new int[]{6, 0, 0, 0, 0}, 30, MoleculeType.A));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 3, 2, 2}, 10, MoleculeType.A));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 1, 4, 2}, 20, MoleculeType.A));
        samplePool.get(1).add(new Sample(new int[]{2, 3, 0, 3, 0}, 10, MoleculeType.A));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 0, 5, 3}, 20, MoleculeType.A));
        samplePool.get(1).add(new Sample(new int[]{0, 5, 0, 0, 0}, 20, MoleculeType.B));
        samplePool.get(1).add(new Sample(new int[]{0, 6, 0, 0, 0}, 30, MoleculeType.B));
        samplePool.get(1).add(new Sample(new int[]{0, 2, 2, 3, 0}, 10, MoleculeType.B));
        samplePool.get(1).add(new Sample(new int[]{2, 0, 0, 1, 4}, 20, MoleculeType.B));
        samplePool.get(1).add(new Sample(new int[]{5, 3, 0, 0, 0}, 20, MoleculeType.B));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 5, 0, 0}, 20, MoleculeType.C));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 6, 0, 0}, 30, MoleculeType.C));
        samplePool.get(1).add(new Sample(new int[]{2, 3, 0, 0, 2}, 10, MoleculeType.C));
        samplePool.get(1).add(new Sample(new int[]{3, 0, 2, 2, 0}, 10, MoleculeType.C));
        samplePool.get(1).add(new Sample(new int[]{4, 2, 0, 0, 1}, 20, MoleculeType.C));
        samplePool.get(1).add(new Sample(new int[]{0, 5, 3, 0, 0}, 20, MoleculeType.C));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 0, 0, 5}, 20, MoleculeType.D));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 0, 6, 0}, 30, MoleculeType.D));
        samplePool.get(1).add(new Sample(new int[]{2, 0, 0, 2, 3}, 10, MoleculeType.D));
        samplePool.get(1).add(new Sample(new int[]{1, 4, 2, 0, 0}, 20, MoleculeType.D));
        samplePool.get(1).add(new Sample(new int[]{0, 3, 0, 2, 3}, 10, MoleculeType.D));
        samplePool.get(1).add(new Sample(new int[]{3, 0, 0, 0, 5}, 20, MoleculeType.D));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 0, 0, 5}, 20, MoleculeType.E));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 0, 0, 6}, 30, MoleculeType.E));
        samplePool.get(1).add(new Sample(new int[]{3, 2, 2, 0, 0}, 10, MoleculeType.E));
        samplePool.get(1).add(new Sample(new int[]{0, 1, 4, 2, 0}, 20, MoleculeType.E));
        samplePool.get(1).add(new Sample(new int[]{3, 0, 3, 0, 2}, 10, MoleculeType.E));
        samplePool.get(1).add(new Sample(new int[]{0, 0, 5, 3, 0}, 20, MoleculeType.E));
        samplePool.get(2).add(new Sample(new int[]{0, 0, 0, 0, 7}, 40, MoleculeType.A));
        samplePool.get(2).add(new Sample(new int[]{3, 0, 0, 0, 7}, 50, MoleculeType.A));
        samplePool.get(2).add(new Sample(new int[]{3, 0, 0, 3, 6}, 40, MoleculeType.A));
        samplePool.get(2).add(new Sample(new int[]{0, 3, 3, 5, 3}, 30, MoleculeType.A));
        samplePool.get(2).add(new Sample(new int[]{7, 0, 0, 0, 0}, 40, MoleculeType.B));
        samplePool.get(2).add(new Sample(new int[]{7, 3, 0, 0, 0}, 50, MoleculeType.B));
        samplePool.get(2).add(new Sample(new int[]{6, 3, 0, 0, 3}, 40, MoleculeType.B));
        samplePool.get(2).add(new Sample(new int[]{3, 0, 3, 3, 5}, 30, MoleculeType.B));
        samplePool.get(2).add(new Sample(new int[]{0, 7, 0, 0, 0}, 40, MoleculeType.C));
        samplePool.get(2).add(new Sample(new int[]{0, 7, 3, 0, 0}, 50, MoleculeType.C));
        samplePool.get(2).add(new Sample(new int[]{3, 6, 3, 0, 0}, 40, MoleculeType.C));
        samplePool.get(2).add(new Sample(new int[]{5, 3, 0, 3, 3}, 30, MoleculeType.C));
        samplePool.get(2).add(new Sample(new int[]{0, 0, 7, 0, 0}, 40, MoleculeType.D));
        samplePool.get(2).add(new Sample(new int[]{0, 0, 7, 3, 0}, 50, MoleculeType.D));
        samplePool.get(2).add(new Sample(new int[]{0, 3, 6, 3, 0}, 40, MoleculeType.D));
        samplePool.get(2).add(new Sample(new int[]{3, 5, 3, 0, 3}, 30, MoleculeType.D));
        samplePool.get(2).add(new Sample(new int[]{0, 0, 0, 7, 0}, 40, MoleculeType.E));
        samplePool.get(2).add(new Sample(new int[]{0, 0, 0, 7, 3}, 50, MoleculeType.E));
        samplePool.get(2).add(new Sample(new int[]{0, 0, 3, 6, 3}, 40, MoleculeType.E));
        samplePool.get(2).add(new Sample(new int[]{3, 3, 5, 3, 0}, 30, MoleculeType.E));

        for (int rank = 0; rank < SAMPLE_RANK_COUNT; ++rank) {
            Collections.shuffle(samplePool.get(rank), random);
        }

    }

    private void initDiagnonisModule() {
        for (int i = 0; i < INIT_DIAGNOSED_SAMPLES_BY_LEAGUE_LEVEL[LEAGUE_LEVEL]; i++) {
            int rank = 0;
            Sample sample = samplePool.get(rank).pop();
            samplePool.get(rank).add(sample.clone());

            sample.id = Sample.ENTITY_COUNT++;
            sample.rank = rank;
            sample.setDiscovered(true);
            if (LEAGUE_LEVEL <= 1) {
                sample.expertise = null;
            }
            storedSamples.add(sample);
        }
    }

    private void initMap() {
        distances = new HashMap<>();
        if (LEAGUE_LEVEL >= 2) {
            distances.put(new ModulePair(Module.START_POS, Module.SAMPLES), 2);
            distances.put(new ModulePair(Module.START_POS, Module.DIAGNOSIS), 2);
            distances.put(new ModulePair(Module.START_POS, Module.MOLECULES), 2);
            distances.put(new ModulePair(Module.START_POS, Module.LABORATORY), 2);
            distances.put(new ModulePair(Module.SAMPLES, Module.DIAGNOSIS), 3);
            distances.put(new ModulePair(Module.SAMPLES, Module.MOLECULES), 3);
            distances.put(new ModulePair(Module.SAMPLES, Module.LABORATORY), 3);
            distances.put(new ModulePair(Module.DIAGNOSIS, Module.MOLECULES), 3);
            distances.put(new ModulePair(Module.DIAGNOSIS, Module.LABORATORY), 4);
            distances.put(new ModulePair(Module.MOLECULES, Module.LABORATORY), 3);
        } else {
            distances.put(new ModulePair(Module.START_POS, Module.SAMPLES), 1);
            distances.put(new ModulePair(Module.START_POS, Module.DIAGNOSIS), 1);
            distances.put(new ModulePair(Module.START_POS, Module.MOLECULES), 1);
            distances.put(new ModulePair(Module.START_POS, Module.LABORATORY), 1);
            distances.put(new ModulePair(Module.SAMPLES, Module.DIAGNOSIS), 1);
            distances.put(new ModulePair(Module.SAMPLES, Module.MOLECULES), 1);
            distances.put(new ModulePair(Module.SAMPLES, Module.LABORATORY), 1);
            distances.put(new ModulePair(Module.DIAGNOSIS, Module.MOLECULES), 1);
            distances.put(new ModulePair(Module.DIAGNOSIS, Module.LABORATORY), 1);
            distances.put(new ModulePair(Module.MOLECULES, Module.LABORATORY), 1);
        }
    }

    @Override
    protected Properties getConfiguration() {
        Properties prop = new Properties();
        prop.setProperty("seed", String.valueOf(seed));
        return prop;
    }

    @Override
    protected String[] getInitInputForPlayer(int playerIdx) {
        List<String> lines = new ArrayList<>();
        lines.add(String.valueOf(scienceProjects.size()));
        for (ScienceProject project : scienceProjects) {
            lines.add(resourceArrayToString(project.cost));
        }

        return lines.toArray(new String[lines.size()]);
    }

    @Override
    protected void prepare(int round) {
        transfers.clear();
        diagnoses.clear();
        cloudRequests.clear();
        projectCompletions.clear();
        for (PlayerData player : players) {
            player.reset();
        }
    }

    @Override
    protected String[] getInputForPlayer(int round, int playerIdx) {
        List<String> lines = new ArrayList<>();
        List<String> sampleLines = new ArrayList<>();

        Stream<PlayerData> a = players.stream().filter(p -> (p.index == playerIdx));
        Stream<PlayerData> b = players.stream().filter(p -> (p.index != playerIdx));
        List<PlayerData> reordered = Stream.concat(a, b).collect(Collectors.toList());
        reordered.stream().forEachOrdered(player -> {
            StringJoiner sj = new StringJoiner(" ");
            sj.add(player.target.name());
            sj.add(String.valueOf(player.eta));
            sj.add(String.valueOf(player.score));
            sj.add(resourceArrayToString(player.storage));
            sj.add(resourceArrayToString(player.expertise));

            for (Sample sample : player.tray) {
                int carrier = player.index == playerIdx ? 0 : 1;
                if (sample.isDiscovered()) {
                    sampleLines.add(join(sample.id, carrier, sample.rank + 1, sample.getGainChar(), sample.life, resourceArrayToString(sample.cost)));
                } else {
                    sampleLines.add(join(sample.id, carrier, sample.rank + 1, "0 -1 -1 -1 -1 -1 -1"));
                }
            }
            lines.add(sj.toString());
        });

        for (Sample sample : storedSamples) {
            sampleLines.add(join(sample.id, -1, sample.rank, sample.getGainChar(), sample.life, resourceArrayToString(sample.cost)));
        }

        lines.add(Arrays.stream(MoleculeType.values()).map(type -> String.valueOf(Math.max(0, molecules.get(type)))).collect(Collectors.joining(" ")));
        lines.add(String.valueOf(sampleLines.size()));
        lines.addAll(sampleLines);

        return lines.toArray(new String[lines.size()]);

    }

    @Override
    protected int getExpectedOutputLineCountForPlayer(int playerIdx) {
        return 1;
    }

    @Override
    protected void handlePlayerOutput(int frame, int round, int playerIdx, String[] outputs) throws WinException, LostException, InvalidInputException {
        String line = outputs[0];
        PlayerData player = players.get(playerIdx);

        try {
            if (player.isMoving()) {
                player.setMessage(line);
                return;
            }

            Matcher match = PLAYER_MOVE_PATTERN.matcher(line);
            if (match.matches()) {
                // Movement
                String module = match.group("module");

                Module target = Module.valueOf(module.toUpperCase());
                if (target == Module.SAMPLES && LEAGUE_LEVEL == 0) {
                    throw new InvalidInputException(EXPECTED_BY_LEAGUE_LEVEL[LEAGUE_LEVEL], line);
                }

                if (player.target != target) {
                    player.from = player.target;
                    player.target = target;
                    player.eta = distances.get(new ModulePair(player.target, player.from));
                }

                // Message
                matchMessage(player, match);
                return;
            }

            match = PLAYER_USE_PATTERN.matcher(line);
            if (match.matches()) {
                // Connect to machine
                String data = match.group("data");
                player.attemptConnection = true;
                player.connectionData = data;

                connectToMachine(player, data);

                // Message
                matchMessage(player, match);
                return;
            }

            match = PLAYER_WAIT_PATTERN.matcher(line);
            if (match.matches()) {
                // Message
                matchMessage(player, match);
                return;
            }

            throw new InvalidInputException(EXPECTED_BY_LEAGUE_LEVEL[LEAGUE_LEVEL], line);

        } catch (LostException | InvalidInputException e) {
            player.die(round);
            throw e;
        } catch (Exception e) {
            player.die(round);
            throw new InvalidInputException(EXPECTED_BY_LEAGUE_LEVEL[LEAGUE_LEVEL], line);
        }
    }

    private void connectToMachine(PlayerData player, String data) throws LostException {
        try {
            switch (player.target) {
                case SAMPLES:
                    try {
                        requestSample(player, Integer.valueOf(data));
                    } catch (NumberFormatException e) {
                        throw new LostException("badSampleRank", data);
                    }
                    break;
                case MOLECULES:
                    MoleculeType molecule;
                    try {
                        molecule = MoleculeType.valueOf(data.toUpperCase());
                    } catch (Exception e) {
                        throw new LostException("unknownMoleculeType", data != null ? data : "");
                    }
                    requestMolecule(player, molecule);
                    break;
                case DIAGNOSIS:
                    requestDiagnosis(player, Integer.valueOf(data));
                    break;
                case LABORATORY:
                    requestProduction(player, Integer.valueOf(data));
                    break;
                case START_POS:
                    throw new LostException("connectToNothing");
                default:
                    break;
            }
        } catch (LostException le) {
            le.setTooltipCode("InvalidConnect");
            throw le;
        }
    }

    private void requestProduction(PlayerData player, Integer data) throws LostException {
        if (data == null) {
            throw new LostException("nullIsInvalidSample");
        }

        Optional<Sample> target = player.tray.stream().filter(sample -> data.equals(sample.id)).findFirst();
        if (target.isPresent()) {
            Sample sample = target.get();
            if (canAfford(player, sample.cost)) {
                transfers.add(new ProductionTransfer(player, sample));
                return;
            }
            throw new LostException("cannotAffordSample", data);
        }
        throw new LostException("sampleNotInTray", data);
    }

    private boolean canAfford(PlayerData player, int[] cost) {
        for (int i = 0; i < MoleculeType.values().length; ++i) {
            if (player.expertise[i] + player.storage[i] < cost[i]) {
                return false;
            }
        }
        return true;
    }

    private void requestDiagnosis(PlayerData player, Integer data) throws LostException {
        if (data == null) {
            throw new LostException("nullIsInvalidSample");
        }

        Optional<Sample> target = player.tray.stream().filter(sample -> data.equals(sample.id)).findFirst();

        if (target.isPresent()) {
            Sample sample = target.get();
            if (sample.isDiscovered()) {
                transfers.add(new SampleTransfer(player, sample, Bound.TO_DIAGNOSIS));
                return;
            } else if (!sample.isDiscovered()) {
                // Diagnose
                diagnoses.add(new Diagnosis(player, sample));
                sample.setDiscovered(true);
                sample.discoveredBy = player;
                return;
            }
        } else {
            target = storedSamples.stream().filter(sample -> data.equals(sample.id)).findFirst();
            if (!target.isPresent()) {
                throw new LostException("sampleNotFound", data);
            }
            if (player.tray.size() >= MAX_TRAY) {
                throw new LostException("trayIsFull");
            }
            Sample sample = target.get();
            SampleTransfer transfer = new SampleTransfer(player, sample, Bound.FROM_DIAGNOSIS);

            if (cloudRequests.get(sample) == null || transfer.player == sample.discoveredBy) {
                cloudRequests.put(sample, transfer);
            } else if (LEAGUE_LEVEL == 0) {
                Sample clonedSample = sample.clone();
                clonedSample.id = Sample.ENTITY_COUNT++;
                clonedSample.setDiscovered(true);
                transfer.setClone(clonedSample);
                cloudRequests.put(clonedSample, transfer);
            }
        }

    }

    private void requestMolecule(PlayerData player, MoleculeType type) throws LostException {
        if (molecules.get(type) <= 0) {
            throw new LostException("notEnoughMolecules", type.name());
        }
        if (Arrays.stream(player.storage).sum() >= MAX_STORAGE) {
            throw new LostException("storageIsFull");
        }
        transfers.add(new ResourceTransfer(player, type));
    }

    private void requestSample(PlayerData player, int rank) throws LostException {
        if (player.tray.size() >= MAX_TRAY) {
            throw new LostException("trayIsFull");
        }

        if (rank < 1 || rank > 3) {
            // throw new LostException("badSampleRank", String.valueOf(rank));
        }

        Sample sample = samplePool.get(rank - 1).pop();
        // Just recycle it right back in there.
        samplePool.get(rank - 1).add(sample.clone());

        sample.id = Sample.ENTITY_COUNT++;
        sample.rank = rank - 1;
        sample.setDiscovered(false);

        if (LEAGUE_LEVEL <= 1) {
            sample.expertise = null;
        }

        transfers.add(new SampleTransfer(player, sample, Bound.FROM_SAMPLES));

    }

    private void matchMessage(PlayerData player, Matcher match) {
        player.setMessage(match.group("message"));
    }

    public double distance(Point a, Point b) {
        return Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));
    }

    @Override
    protected void updateGame(int round) throws GameOverException {
        // Move players
        for (PlayerData player : players) {
            if (player.eta != 0) {
                player.eta--;
                player.moved = true;
            }
        }

        // Perform transfers
        for (SampleTransfer transfer : cloudRequests.values()) {
            transfers.add(transfer);
        }
        for (Transfer transfer : transfers) {
            transfer.apply(this);
        }

        // Check for science projects
        List<Runnable> removes = new LinkedList<>();
        for (PlayerData player : players) {
            for (ScienceProject project : scienceProjects) {
                if (completedProject(player, project)) {
                    removes.add(() -> {
                        scienceProjects.remove(project);
                    });
                    player.score += SCIENCE_PROJECT_VALUE;
                    projectCompletions.add(new ProjectCompletion(player, project));
                    addToolTip(player.index, translate("ProjectTooltip", player.index));
                }
            }

        }
        for (Runnable r : removes) {
            r.run();
        }

    }

    private boolean completedProject(PlayerData player, ScienceProject project) {
        for (int i = 0; i < project.cost.length; ++i) {
            if (player.expertise[i] < project.cost[i]) {
                return false;
            }
        }
        return true;
    }

    @Override
    protected void populateMessages(Properties p) {
        p.put("notEnoughMolecules", "Invalid CONNECT: there are no %s type molecules left");
        p.put("trayIsFull", "Invalid CONNECT: your robot may not carry data for more than " + MAX_TRAY + " samples");
        p.put("storageIsFull", "Invalid CONNECT: your robot may not carry more than " + MAX_STORAGE + " molecules");
        p.put("nullIsInvalidSample", "Invalid CONNECT: you must specify a Sample ID to connect to this module");
        p.put("sampleNotFound", "Invalid CONNECT: the sample %d is not available");
        p.put("badSampleRank", "Invalid CONNECT: there is no sample with rank %s");
        p.put("sampleNotInTray", "Invalid CONNECT: you are not carrying sample %d");
        p.put("unknownMoleculeType", "Invalid CONNECT: invalid molecule %s");
        p.put("cannotAffordSample", "Invalid CONNECT: you do not have enough molecules/expertise to launch research on sample %d");
        p.put("connectToNothing", "Invalid CONNECT: you must go to a module before using the connect command");
        p.put("InvalidConnect", "Invalid CONNECT");
        p.put("ProjectTooltip", "$0 completes a science project!");
        p.put("production", "$%d researched medecine for sample %d, scored %d health points and gained expertise in molecule %s");
        p.put("productionNoGain", "$%d researched medecine for sample %d, scored %d health points");
        p.put("upload", "$%d stores sample %d on the cloud.");
        p.put("newSample", "$%d receives sample %d.");
        p.put("download", "$%d downloads sample %d from the cloud.");
        p.put("takeMolecule", "$%d receives a %s molecule.");
        p.put("etaSAMPLES", "$%d will arrive at the samples module in %d turns");
        p.put("etaDIAGNOSIS", "$%d will arrive at the diagnosis module in %d turns");
        p.put("etaMOLECULES", "$%d will arrive at the molecules module in %d turns");
        p.put("etaLABORATORY", "$%d will arrive at the laboratory module in %d turns");
        p.put("etaSAMPLESsingular", "$%d will arrive at the samples module in %d turn");
        p.put("etaDIAGNOSISsingular", "$%d will arrive at the diagnosis module in %d turn");
        p.put("etaMOLECULESsingular", "$%d will arrive at the molecules module in %d turn");
        p.put("etaLABORATORYsingular", "$%d will arrive at the laboratory module in %d turn");
        p.put("diagnosis", "$%d has diagnosed sample %d");
        p.put("projectCompletion", "$%d has completed the science project %d and scores " + SCIENCE_PROJECT_VALUE + " health points.");

    }

    @Override
    protected String[] getInitDataForView() {
        List<String> lines = new ArrayList<>();
        lines.add(SCIENCE_PROJECT_VALUE + " " + LEAGUE_LEVEL);

        lines.add(String.valueOf(scienceProjects.size()));
        for (ScienceProject project : scienceProjects) {
            lines.add(resourceArrayToString(project.cost));
        }

        lines.add(String.valueOf(storedSamples.size()));
        for (Sample sample : storedSamples) {
            lines.add(join(sample.id, resourceArrayToString(sample.cost), sample.rank, sample.life, sample.expertise));
        }

        lines.add(0, String.valueOf(lines.size() + 1));
        return lines.toArray(new String[lines.size()]);
    }

    private String resourceArrayToString(int[] array) {
        return Arrays.stream(array).mapToObj(Integer::toString).collect(Collectors.joining(" "));
    }

    protected String[] getFrameDataForView(int round, int frame, boolean keyFrame) {
        List<String> lines = new ArrayList<>();

        // Players
        for (PlayerData player : players) {
            Integer total = distances.get(new ModulePair(player.target, player.from));

            StringJoiner joiner = new StringJoiner(" ");
            joiner.add(player.target.name());
            joiner.add(player.from.name());
            joiner.add(String.valueOf(player.eta));
            joiner.add(player.moved ? "1" : "0");
            joiner.add((total == null) ? "0" : String.valueOf(total));
            joiner.add(String.valueOf(resourceArrayToString(player.storage)));
            joiner.add(String.valueOf(resourceArrayToString(player.expertise)));
            joiner.add(String.valueOf(player.score));
            joiner.add(player.dead ? "1" : "0");
            joiner.add(";" + (player.message == null ? "" : player.message));
            lines.add(joiner.toString());
        }

        // Resources
        lines.add(Arrays.stream(MoleculeType.values()).map(type -> String.valueOf(molecules.get(type))).collect(Collectors.joining(" ")));

        // Events
        List<String> eventLines = new LinkedList<>();
        for (Transfer transfer : transfers) {
            if (transfer instanceof SampleTransfer) {
                SampleTransfer st = (SampleTransfer) transfer;
                if (st.bound.equals(Bound.FROM_SAMPLES)) {
                    eventLines.add(join(EV_NEW_SAMPLE, st.sample.id, resourceArrayToString(st.sample.cost), st.sample.rank, st.sample.life, st.sample.expertise, st.player.index));
                } else if (st.bound.equals(Bound.FROM_DIAGNOSIS)) {
                    if (st.clone != null) {
                        eventLines.add(join(EV_CLONE_INITAL_SAMPLE, st.clone.id, resourceArrayToString(st.clone.cost), st.clone.rank, st.clone.life, st.clone.expertise));
                        eventLines.add(join(EV_TAKE_SAMPLE, st.clone.id, st.player.index));
                    } else {
                        eventLines.add(join(EV_TAKE_SAMPLE, st.sample.id, st.player.index));
                    }
                } else {
                    eventLines.add(join(EV_STORE_SAMPLE, st.sample.id, st.player.index));
                }
            } else if (transfer instanceof ResourceTransfer) {
                ResourceTransfer rt = (ResourceTransfer) transfer;
                eventLines.add(join(EV_TAKE_RESOURCE, rt.resourceType, rt.player.index));
            } else {
                ProductionTransfer pt = (ProductionTransfer) transfer;
                eventLines.add(join(EV_PRODUCE, pt.sample.id));
            }
        }
        for (Diagnosis diagnosis : diagnoses) {
            eventLines.add(join(EV_DIAGNOSE, diagnosis.sample.id));
        }
        lines.add(String.valueOf(eventLines.size()));
        lines.addAll(eventLines);

        return lines.toArray(new String[lines.size()]);
    }

    @SafeVarargs
    static final <T> String join(T... v) {
        return Stream.of(v).map(String::valueOf).collect(Collectors.joining(" "));
    }

    @Override
    protected String getGameName() {
        return "Roche";
    }

    @Override
    protected String getHeadlineAtGameStartForConsole() {
        return null;
    }

    @Override
    protected int getMinimumPlayerCount() {
        return 2;
    }

    @Override
    protected boolean showTooltips() {
        return true;
    }

    @Override
    protected String[] getPlayerActions(int playerIdx, int round) {
        return new String[0];
    }

    @Override
    protected boolean isPlayerDead(int playerIdx) {
        return players.get(playerIdx).dead;
    }

    @Override
    protected String getDeathReason(int playerIdx) {
        return "$" + playerIdx + ": Eliminated!";
    }

    @Override
    protected int getMillisTimeForRound() {
        return 50;
    }

    @Override
    protected int getScore(int playerIdx) {
        PlayerData player = players.get(playerIdx);
        return player.score;
    }

    @Override
    protected String[] getGameSummary(int round) {
        List<String> lines = new ArrayList<>();
        for (int i = 0; i < players.size(); ++i) {
            lines.addAll(getPlayerSummary(i, round));
        }
        return lines.toArray(new String[lines.size()]);
    }

    protected List<String> getPlayerSummary(int playerIdx, int round) {
        List<String> lines = new ArrayList<>();
        PlayerData player = players.get(playerIdx);

        for (Transfer t : transfers) {
            if (t.player == player) {
                Translatable summary = t.getSummary();
                lines.add(translate(summary.code, summary.values));
            }
        }

        for (Diagnosis d : diagnoses) {
            if (d.player == player) {
                lines.add(translate("diagnosis", playerIdx, d.sample.id));
            }
        }

        if (player.isMoving()) {
            lines.add(translate("eta" + player.target + (player.eta == 1 ? "singular" : ""), playerIdx, player.eta));
        }

        for (ProjectCompletion projectCompletion : projectCompletions) {
            if (projectCompletion.player == player) {
                lines.add(translate("projectCompletion", playerIdx, projectCompletion.project.index));
            }
        }

        if (player.dead) {
            if (player.deadAt == round) {
                lines.add(getDeathReason(playerIdx));
            }
        }
        return lines;
    }

    @Override
    protected void setPlayerTimeout(int frame, int round, int playerIdx) {
        PlayerData player = players.get(playerIdx);
        player.die(round);
    }

    @Override
    protected int getMaxRoundCount(int playerCount) {
        return 200;
    }

    @Override
    protected boolean gameOver() {
        return super.gameOver() || players.stream().anyMatch(p -> p.score >= MAX_SCORE);
    }

    public static void main(String... args) throws IOException {
        new Referee(System.in, System.out, System.err).start();
    }
}

// ------------------------------------------------------------------------------------------------------------

abstract class MultiReferee extends AbstractReferee {
    private Properties properties;

    public MultiReferee(InputStream is, PrintStream out, PrintStream err) throws IOException {
        super(is, out, err);
    }

    @Override
    protected final void handleInitInputForReferee(int playerCount, String[] init) throws InvalidFormatException {
        properties = new Properties();
        try {
            for (String s : init) {
                properties.load(new StringReader(s));
            }
        } catch (IOException e) {
        }
        initReferee(playerCount, properties);
        properties = getConfiguration();
    }

    abstract protected void initReferee(int playerCount, Properties prop) throws InvalidFormatException;

    abstract protected Properties getConfiguration();

    protected void appendDataToEnd(PrintStream stream) throws IOException {
        stream.println(OutputCommand.UINPUT.format(properties.size()));
        for (Entry<Object, Object> t : properties.entrySet()) {
            stream.println(t.getKey() + "=" + t.getValue());
        }
    }
}

abstract class AbstractReferee {
    private static final Pattern HEADER_PATTERN = Pattern.compile("\\[\\[(?<cmd>.+)\\] ?(?<lineCount>[0-9]+)\\]");
    private static final String LOST_PARSING_REASON_CODE = "INPUT";
    private static final String LOST_PARSING_REASON = "Failure: invalid input";

    protected static class PlayerStatus {
        private int id;
        private int score;
        private boolean lost, win;
        private String info;
        private String reasonCode;
        private String[] nextInput;

        public PlayerStatus(int id) {
            this.id = id;
            lost = false;
            info = null;
        }

        public int getScore() {
            return score;
        }

        public boolean isLost() {
            return lost;
        }

        public String getInfo() {
            return info;
        }

        public int getId() {
            return id;
        }

        public String getReasonCode() {
            return reasonCode;
        }

        public String[] getNextInput() {
            return nextInput;
        }
    }

    private Properties messages = new Properties();

    @SuppressWarnings("serial")
    final class InvalidFormatException extends Exception {
        public InvalidFormatException(String message) {
            super(message);
        }
    }

    @SuppressWarnings("serial")
    abstract class GameException extends Exception {
        private String reasonCode, tooltipCode;
        private Object[] values;

        public GameException(String reasonCode, Object... values) {
            this.reasonCode = reasonCode;
            this.values = values;
        }

        public void setTooltipCode(String tooltipCode) {
            this.tooltipCode = tooltipCode;
        }

        public String getReason() {
            if (reasonCode != null) {
                return translate(reasonCode, values);
            } else {
                return null;
            }
        }

        public String getReasonCode() {
            return reasonCode;
        }

        public String getTooltipCode() {
            if (tooltipCode != null) {
                return tooltipCode;
            }
            return getReasonCode();
        }
    }

    @SuppressWarnings("serial")
    class LostException extends GameException {
        public LostException(String reasonCode, Object... values) {
            super(reasonCode, values);
        }
    }

    @SuppressWarnings("serial")
    class WinException extends GameException {
        public WinException(String reasonCode, Object... values) {
            super(reasonCode, values);
        }
    }

    @SuppressWarnings("serial")
    class InvalidInputException extends GameException {
        public InvalidInputException(String expected, String found) {
            super("InvalidInput", expected, found);
        }
    }

    @SuppressWarnings("serial")
    class GameOverException extends GameException {
        public GameOverException(String reasonCode, Object... values) {
            super(reasonCode, values);
        }
    }

    @SuppressWarnings("serial")
    class GameErrorException extends Exception {
        public GameErrorException(Throwable cause) {
            super(cause);
        }
    }

    public static enum InputCommand {
        INIT, GET_GAME_INFO, SET_PLAYER_OUTPUT, SET_PLAYER_TIMEOUT
    }

    public static enum OutputCommand {
        VIEW, INFOS, NEXT_PLAYER_INPUT, NEXT_PLAYER_INFO, SCORES, UINPUT, TOOLTIP, SUMMARY;

        public String format(int lineCount) {
            return String.format("[[%s] %d]", this.name(), lineCount);
        }
    }

    @SuppressWarnings("serial")
    public static class OutputData extends LinkedList<String> {
        private OutputCommand command;

        public OutputData(OutputCommand command) {
            this.command = command;
        }

        public boolean add(String s) {
            if (s != null)
                return super.add(s);
            return false;
        }

        public void addAll(String[] data) {
            if (data != null)
                super.addAll(Arrays.asList(data));
        }

        @Override
        public String toString() {
            StringWriter writer = new StringWriter();
            PrintWriter out = new PrintWriter(writer);
            out.println(this.command.format(this.size()));
            for (String line : this) {
                out.println(line);
            }
            return writer.toString().trim();
        }
    }

    private static class Tooltip {
        int player;
        String message;

        public Tooltip(int player, String message) {
            this.player = player;
            this.message = message;
        }

    }

    private Set<Tooltip> tooltips;
    private int playerCount, alivePlayerCount;
    private int currentPlayer, nextPlayer;
    private PlayerStatus lastPlayer, playerStatus;
    private int frame, round;
    private PlayerStatus[] players;
    private String[] initLines;
    private boolean newRound;
    private String reasonCode, reason;

    private InputStream is;
    private PrintStream out;
    private PrintStream err;

    public AbstractReferee(InputStream is, PrintStream out, PrintStream err) throws IOException {
        tooltips = new HashSet<>();
        this.is = is;
        this.out = out;
        this.err = err;
        start();
    }

    @SuppressWarnings("resource")
    public void start() throws IOException {
        try {
            handleInitInputForReferee(2, new String[0]);
        } catch (InvalidFormatException e) {
            return;
        }

        Scanner s = new Scanner(is);

        try {
            // Read ###Start 2
            s.nextLine();
            playerCount = alivePlayerCount = 2;
            players = new PlayerStatus[2];
            players[0] = new PlayerStatus(0);
            players[1] = new PlayerStatus(1);
            playerStatus = players[0];
            currentPlayer = nextPlayer = 1;
            frame = 0;
            round = -1;
            newRound = true;
            //i = 0;
            //err.println(ne);
            
            boolean endReached = false;
            while (round < getMaxRoundCount(2) && !endReached) {
                lastPlayer = playerStatus;
                err.println(nextPlayer);
                playerStatus = nextPlayer();
                err.println(nextPlayer);
                if (this.round >= getMaxRoundCount(this.playerCount)) {		
                    //out.println("###Error Round limit!");
                    throw new GameOverException("maxRoundsCountReached");		
                }
                if(newRound){
                    prepare(round);
                    if (!this.isTurnBasedGame())
                    {
                        for (PlayerStatus player: this.players) 
                        {		
                            if (!player.lost) {		
                                player.nextInput = getInputForPlayer(round, player.id);
                            } else {		
                                player.nextInput = null;		
                            }   
                        }
                    }
                }
                out.println("###Input "+nextPlayer);
                if(this.round==0){
                    for (String line : getInitInputForPlayer(nextPlayer)) {
                        out.println(line);
                    }
                }
                for(String line : this.players[nextPlayer].nextInput){
                    out.println(line);
                }
                int expectedOutputLineCount = getExpectedOutputLineCountForPlayer(nextPlayer);
                out.println("###Output "+nextPlayer+" "+expectedOutputLineCount);
                ++frame;
                 try {
                    String[] outputs = new String[expectedOutputLineCount];
                    for (int i = 0; i < expectedOutputLineCount; i++) {
                        outputs[i] = s.nextLine();
                    }
                    handlePlayerOutput(frame, round, nextPlayer, outputs);
                } catch (WinException e) {
                    playerStatus.score = getScore(nextPlayer);
                    playerStatus.win = true;
                    playerStatus.info = e.getReason();
                    playerStatus.reasonCode = e.getReasonCode();
                    lastPlayer = playerStatus;
                    throw new GameOverException(null);
                    //players[0].win = true;
                    //endReached = true;
                } catch (LostException e) {
                    playerStatus.score = getScore(nextPlayer);
                    playerStatus.lost = true;
                    playerStatus.info = e.getReason();
                    err.println("###Error 0 Lost " + e.getMessage());
                    //players[0].lost = true;
                    //endReached = true;
                } catch (InvalidInputException e) {
                    playerStatus.score = getScore(nextPlayer);
                    playerStatus.lost = true;
                    playerStatus.info = e.getReason();
                    err.println("###Error 0 InvalidInput " + e.getMessage());
                    //players[0].lost = true;
                    //endReached = true;
                }

                
            }
        } catch(GameOverException e){
            //out.println("###Error "+e.getReason());
            newRound = true;
            reasonCode = e.getReasonCode();
            reason = e.getReason();
            err.println(reason);
            prepare(round);
            updateScores();
             if (getScore(0) > getScore(1)) {
                out.println("###End 0 1");
            } else if (getScore(0) < getScore(1)) {
                out.println("###End 1 0");
            } else {
                out.println("###End 01");
            }
            //out.println("###Error ex" + e.getReason());
        } finally {
            s.close();
           
        }
    }

    private PlayerStatus nextPlayer() throws GameOverException {
        currentPlayer = nextPlayer;
        newRound = false;
        do {
            ++nextPlayer;
            if (nextPlayer >= playerCount) {
                nextRound();
                nextPlayer = 0;
            }
        } while (this.players[nextPlayer].lost || this.players[nextPlayer].win);
        return players[nextPlayer];
    }

    protected String getColoredReason(boolean error, String reason) {
        if (error) {
            return String.format("¤RED¤%s§RED§", reason);
        } else {
            return String.format("¤GREEN¤%s§GREEN§", reason);
        }
    }

    private void dumpView() {
        OutputData data = new OutputData(OutputCommand.VIEW);
        String reasonCode = this.reasonCode;
        if (reasonCode == null && playerStatus != null)
            reasonCode = playerStatus.reasonCode;

        if (newRound) {
            if (reasonCode != null) {
                data.add(String.format("KEY_FRAME %d %s", this.frame, reasonCode));
            } else {
                data.add(String.format("KEY_FRAME %d", this.frame));
            }
            if (frame == 0) {
                data.add(getGameName());
                data.addAll(getInitDataForView());
            }
        } else {
            if (reasonCode != null) {
                data.add(String.format("INTERMEDIATE_FRAME %d %s", this.frame, reasonCode));
            } else {
                data.add(String.format("INTERMEDIATE_FRAME %d", frame));
            }
        }
        if (newRound || isTurnBasedGame()) {
            data.addAll(getFrameDataForView(round, frame, newRound));
        }

        out.println(data);
    }

    private void dumpInfos() {
        OutputData data = new OutputData(OutputCommand.INFOS);
        if (reason != null && isTurnBasedGame()) {
            data.add(getColoredReason(true, reason));
        } else {
            if (lastPlayer != null) {
                String head = lastPlayer.info;
                if (head != null) {
                    data.add(getColoredReason(lastPlayer.lost, head));
                } else {
                    if (frame > 0) {
                        data.addAll(getPlayerActions(this.currentPlayer, newRound ? this.round - 1 : this.round));
                    }
                }
            }
        }
        out.println(data);
        if (newRound && round >= -1 && playerCount > 1) {
            OutputData summary = new OutputData(OutputCommand.SUMMARY);
            if (frame == 0) {
                String head = getHeadlineAtGameStartForConsole();
                if (head != null) {
                    summary.add(head);
                }
            }
            if (round >= 0) {
                summary.addAll(getGameSummary(round));
            }
            if (!isTurnBasedGame() && reason != null) {
                summary.add(getColoredReason(true, reason));
            }
            out.println(summary);
        }

        if (!tooltips.isEmpty() && (newRound || isTurnBasedGame())) {
            data = new OutputData(OutputCommand.TOOLTIP);
            for (Tooltip t : tooltips) {
                data.add(t.message);
                data.add(String.valueOf(t.player));
            }
            tooltips.clear();
            out.println(data);
        }
    }

    private void dumpNextPlayerInfos() {
        OutputData data = new OutputData(OutputCommand.NEXT_PLAYER_INFO);
        data.add(String.valueOf(nextPlayer));
        data.add(String.valueOf(getExpectedOutputLineCountForPlayer(nextPlayer)));
        if (this.round == 0) {
            data.add(String.valueOf(getMillisTimeForFirstRound()));
        } else {
            data.add(String.valueOf(getMillisTimeForRound()));
        }
        out.println(data);
    }

    private void dumpNextPlayerInput() {
        OutputData data = new OutputData(OutputCommand.NEXT_PLAYER_INPUT);
        if (this.round == 0) {
            data.addAll(getInitInputForPlayer(nextPlayer));
        }
        if (this.isTurnBasedGame()) {
            this.players[nextPlayer].nextInput = getInputForPlayer(round, nextPlayer);
        }
        data.addAll(this.players[nextPlayer].nextInput);
        out.println(data);
    }

    protected final String translate(String code, Object... values) {
        try {
            return String.format((String) messages.get(code), values);
        } catch (NullPointerException e) {
            return code;
        }
    }

    protected final void printError(Object message) {
        err.println(message);
    }

    protected int getMillisTimeForFirstRound() {
        return 1000;
    }

    protected int getMillisTimeForRound() {
        return 150;
    }

    protected int getMaxRoundCount(int playerCount) {
        return 400;
    }

    private void nextRound() throws GameOverException {
        newRound = true;
        if (++round > 0) {
            updateGame(round);
        }
        if (gameOver()) {
            throw new GameOverException(null);
        }
    }

    protected boolean gameOver() {
        return alivePlayerCount < getMinimumPlayerCount();
    }

    private void updateScores() {
        for (int i = 0; i < playerCount; ++i) {
            if (!players[i].lost && isPlayerDead(i)) {
                alivePlayerCount--;
                players[i].lost = true;
                players[i].info = getDeathReason(i);
                addToolTip(i, players[i].info);
            }
            players[i].score = getScore(i);
        }
    }

    protected void addToolTip(int player, String message) {
        if (showTooltips())
            tooltips.add(new Tooltip(player, message));
    }

    /**
     * Add message (key = reasonCode, value = reason)
     *
     * @param p
     */
    protected abstract void populateMessages(Properties p);

    protected boolean isTurnBasedGame() {
        return false;
    }

    protected abstract void handleInitInputForReferee(int playerCount, String[] init) throws InvalidFormatException;

    protected abstract String[] getInitDataForView();

    protected abstract String[] getFrameDataForView(int round, int frame, boolean keyFrame);

    protected abstract int getExpectedOutputLineCountForPlayer(int playerIdx);

    protected abstract String getGameName();

    protected abstract void appendDataToEnd(PrintStream stream) throws IOException;

    protected abstract void handlePlayerOutput(int frame, int round, int playerIdx, String[] output) throws WinException, LostException, InvalidInputException;

    protected abstract String[] getInitInputForPlayer(int playerIdx);

    protected abstract String[] getInputForPlayer(int round, int playerIdx);

    protected abstract String getHeadlineAtGameStartForConsole();

    protected abstract int getMinimumPlayerCount();

    protected abstract boolean showTooltips();

    /**
     * @param round
     * @return scores of all players
     * @throws GameOverException
     */
    protected abstract void updateGame(int round) throws GameOverException;

    protected abstract void prepare(int round);

    protected abstract boolean isPlayerDead(int playerIdx);

    protected abstract String getDeathReason(int playerIdx);

    protected abstract int getScore(int playerIdx);

    protected abstract String[] getGameSummary(int round);

    protected abstract String[] getPlayerActions(int playerIdx, int round);

    protected abstract void setPlayerTimeout(int frame, int round, int playerIdx);
}