Arakne / Araknemu

public final class PlacementState implements LeavableState, EventsSubscriber {

    private long startTime;

    private Fight fight;

    private Listener[] listeners;

    private Map<FightTeam, PlacementCellsGenerator> cellsGenerators;

    private ScheduledFuture<?> timer;

    private final boolean randomize;

    public PlacementState() {

        this(true);

    }

    public PlacementState(boolean randomize) {

        this.randomize = randomize;

    }

    @Override

    public void start(Fight fight) {

        this.fight = fight;

        this.cellsGenerators = new HashMap<>();

        for (FightTeam team : fight.teams()) {

            cellsGenerators.put(

                team,

                randomize

                    ? PlacementCellsGenerator.randomized(fight.map(), team.startPlaces())

                    : new PlacementCellsGenerator(fight.map(), team.startPlaces())

            );

        }

        fight.dispatcher().register(this);

        startTime = System.currentTimeMillis();

        addFighters(fight.fighters(false));

        if (fight.type().hasPlacementTimeLimit()) {

            timer = fight.schedule(this::innerStartFight, fight.type().placementDuration());

        }

    }

    @Override

    public int id() {

        return 2;

    }

    @Override

    public Listener[] listeners() {

        if (listeners != null) {

            return listeners;

        }

        return listeners = new Listener[] {

            new SendFighterPositions(fight),

            new SendFighterReadyState(fight),

            new StartFightWhenAllReady(fight, this),

            new SendNewFighter(fight),

            new ClearFighter(),

            new SendFighterRemoved(fight),

            new SendJoinTeamOptionChangedMessage(),

            new SendNeedHelpOptionChangedMessage(),

        };

    }

    /**

     * Get the remaining placement time, in milliseconds

     */

    public long remainingTime() {

        if (!fight.type().hasPlacementTimeLimit()) {

            throw new UnsupportedOperationException("The fight has no placement time limit");

        }

        return fight.type().placementDuration().toMillis() + startTime - System.currentTimeMillis();

    }

    /**

     * Try to change fighter start place

     *

     * @param fighter Fighter to move

     * @param cell The target cell

     */

    public synchronized void changePlace(Fighter fighter, FightCell cell) {

        if (invalidState()) {

            return;

        }

        if (fighter.ready()) {

            throw new FightException("The fighter is ready");

        }

        if (!cell.walkable()) {

            throw new FightMapException("Not walkable");

        }

        if (!fighter.team().startPlaces().contains(cell.id())) {

            throw new FightException("Bad start cell");

        }

        fighter.move(cell);

        fight.dispatch(new FighterPlaceChanged(fighter));

    }

    /**

     * Try to join a team

     *

     * @param fighter The fighter to add

     * @param team The team

     *

     * @throws JoinFightException When cannot join the team

     */

    public synchronized void joinTeam(Fighter fighter, FightTeam team) throws JoinFightException {

        if (invalidState()) {

            throw new JoinFightException(JoinFightError.CANT_DO_TOO_LATE);

        }

        team.join(fighter);

        addFighters(Collections.singleton(fighter));

    }

    @Override

    public synchronized void leave(Fighter fighter) {

        if (invalidState()) {

            throw new InvalidFightStateException(getClass());

        }

        // Not allowed to leave the fight : punish the fighter

        if (!fight.type().canCancel()) {

            punishDeserter(fighter);

        }

        // Remove fighter

        leaveFromFight(fighter);

    }

    /**

     * Kick a fighter during placement

     * Unlike leave, this method will not punish the fighter

     *

     * @param fighter Fighter to kick

     *

     * @throws InvalidFightStateException When the session state has changed

     */

    public synchronized void kick(Fighter fighter) {

        if (invalidState()) {

            throw new InvalidFightStateException(getClass());

        }

        // Remove fighter

        leaveFromFight(fighter);

    }

    /**

     * Manually start the fight

     */

    public synchronized void startFight() {

        // Try to cancel the timer

        if (timer != null) {

            if (!timer.cancel(false)) {

                return; // Should not occurs : the fight is already started by the timer

            }

        }

        innerStartFight();

    }

    /**

     * Start the fight

     */

    private void innerStartFight() {

        if (invalidState()) {

            return;

        }

        fight.dispatcher().unregister(this);

        fight.nextState();

    }

    /**

     * Leave from a fight :

     * - If the fighter is the team leader, the team is dissolved

     * - The fighter is removed

     * - Check if the fight is valid (has at least two teams)

     */

    private void leaveFromFight(Fighter fighter) {

        // The team leader quit the fight => Dissolve team

        if (fighter.isTeamLeader()) {

            fight.teams().remove(fighter.team());

            fighter.team().fighters().forEach(this::removeFighter);

        } else {

            fighter.team().kick(fighter);

            removeFighter(fighter);

        }

        checkFightValid();

    }

    /**

     * Punish the deserter fighter

     */

    private void punishDeserter(Fighter fighter) {

        final FightRewardsSheet rewardsSheet = fight.type().rewards().generate(

            new EndFightResults(

                fight,

                Collections.emptyList(),

                Collections.singletonList(fighter)

            )

        );

        fighter.dispatch(new FightLeaved(rewardsSheet.rewards().get(0)));

    }

    private void addFighters(Collection<Fighter> fighters) {

        for (Fighter fighter : fighters) {

            fighter.joinFight(fight, cellsGenerators.get(fighter.team()).next());

        }

        for (Fighter fighter : fighters) {

            fighter.dispatch(new FightJoined(fight, fighter));

        }

        for (Fighter fighter : fighters) {

            fight.dispatch(new FighterAdded(fighter));

        }

    }

    /**

     * Notify fight that a fighter has leave

     */

    private void removeFighter(Fighter fighter) {

        fighter.dispatch(new FightLeaved());

        fight.dispatch(new FighterRemoved(fighter, fight));

    }

    /**

     * Check if the fight is valid after fighter leaved

     */

    private void checkFightValid() {

        if (fight.teams().stream().filter(FightTeam::alive).count() > 1) {

            return;

        }

        fight.cancel();

        if (timer != null) {

            timer.cancel(true);

        }

    }

    /**

     * Check if the fight state is not placement

     * This method will return true is the state is active (or following), or if it's cancelled or finished

     */

    private boolean invalidState() {

        return fight.state() != this || !fight.alive();