path: root/src/ch/epfl/xblast/server/Player.java

package ch.epfl.xblast.server;

import ch.epfl.cs108.Sq;
import ch.epfl.xblast.*;

import java.util.Objects;

/**
 * A Player.
 *
 * @author Pacien TRAN-GIRARD (261948)
 * @author Timothée FLOURE (257420)
 */
public final class Player {

    /**
     * The life state of a player.
     */
    public static final class LifeState {

        /**
         * Enum containing all the possible life states.
         */
        public enum State {
            INVULNERABLE,
            VULNERABLE,
            DYING,
            DEAD
        }

        private final int lives;
        private final State state;

        /**
         * Instantiates a new LifeSate.
         *
         * @param lives the number of lives
         * @param state the state
         * @throws IllegalArgumentException if lives is negative
         */
        public LifeState(int lives, State state) {
            this.lives = ArgumentChecker.requireNonNegative(lives);
            this.state = state;
        }

        /**
         * @return the number of lives
         */
        public int lives() {
            return lives;
        }

        /**
         * @return the state
         */
        public State state() {
            return state;
        }

        /**
         * @return true if the actual state allow to move
         */
        public boolean canMove() {
            return (state() == State.INVULNERABLE || state() == State.VULNERABLE);
        }

    }

    /**
     * The "directed" position of a player.
     */
    public static final class DirectedPosition {

        private final SubCell position;
        private final Direction direction;

        /**
         * @return an infinite sequence of directed positions corresponding to a stopped player.
         */
        public static Sq<DirectedPosition> stopped(DirectedPosition p) {
            return Sq.constant(p);
        }

        /**
         * @return an infinite sequence of directed position corresponding to a moving player.
         */
        public static Sq<DirectedPosition> moving(DirectedPosition p) {
            return Sq.iterate(p, x -> x.withPosition(x.position().neighbor(x.direction())));
        }

        /**
         * Instantiates a new DirectedPos
         *
         * @param position  the position of the player
         * @param direction the direction of the player
         * @throws IllegalArgumentException if position or direction is null
         */
        public DirectedPosition(SubCell position, Direction direction) {
            this.position = Objects.requireNonNull(position);
            this.direction = Objects.requireNonNull(direction);
        }

        /**
         * @return the position
         */
        public SubCell position() {
            return position;
        }

        /**
         * @return a new directed position with the given position and the previous direction
         */
        public DirectedPosition withPosition(SubCell newPosition) {
            return new DirectedPosition(newPosition, direction);
        }

        /**
         * @return the direction
         */
        public Direction direction() {
            return direction;
        }

        /**
         * @return a new directed position with the previous position and the given direction
         */
        public DirectedPosition withDirection(Direction newDirection) {
            return new DirectedPosition(position, newDirection);
        }

    }

    /**
     * The default Direction of a new Player.
     */
    private static final Direction DEFAULT_DIRECTION = Direction.S;

    private final PlayerID id;
    private final Sq<LifeState> lifeStates;
    private final Sq<DirectedPosition> directedPos;
    private final int maxBombs;
    private final int bombRange;

    /**
     * Builds a default LifeState sequence with the given number of lives.
     *
     * @param lives number of lives of the desired sequence
     * @return the sequence
     */
    private static Sq<LifeState> buildDefaultLifeStateSequence(int lives) {
        LifeState invulnerability = new LifeState(
                ArgumentChecker.requireNonNegative(lives),
                LifeState.State.INVULNERABLE
        );
        LifeState vulnerability = new LifeState(
                ArgumentChecker.requireNonNegative(lives),
                LifeState.State.VULNERABLE
        );

        return Sq.repeat(Ticks.PLAYER_INVULNERABLE_TICKS, invulnerability).concat(Sq.constant(vulnerability));
    }

    /**
     * Builds a default DirectedPosition sequence at the given position.
     *
     * @param pos the position
     * @return the sequence
     */
    private static Sq<DirectedPosition> buildDefaultDirectedPositionSequence(Cell pos) {
        DirectedPosition dp = new DirectedPosition(
                SubCell.centralSubCellOf(Objects.requireNonNull(pos)),
                Player.DEFAULT_DIRECTION
        );

        return DirectedPosition.stopped(dp);
    }

    /**
     * Instantiates a new Player.
     *
     * @param id          the Player's id
     * @param lifeStates  a sequence of LifeState-s
     * @param directedPos a sequence of DirectedPosition-s
     * @param maxBombs    the maximum number of Bomb-s the Player can carry
     * @param bombRange   the range of the Bomb-s
     * @throws IllegalArgumentException
     * @throws NullPointerException
     */
    public Player(PlayerID id, Sq<LifeState> lifeStates, Sq<DirectedPosition> directedPos, int maxBombs, int bombRange) {
        this.id = Objects.requireNonNull(id);
        this.lifeStates = Objects.requireNonNull(lifeStates);
        this.directedPos = Objects.requireNonNull(directedPos);
        this.maxBombs = ArgumentChecker.requireNonNegative(maxBombs);
        this.bombRange = ArgumentChecker.requireNonNegative(bombRange);
    }

    /**
     * Instantiates a new Player.
     *
     * @param id        the Player's id
     * @param lives     the number of lives of the Player
     * @param position  the starting position of the Player
     * @param maxBombs  the maximum number of Bomb-s the Player can carry
     * @param bombRange the range of the Bomb-s
     * @throws IllegalArgumentException
     * @throws NullPointerException
     */
    public Player(PlayerID id, int lives, Cell position, int maxBombs, int bombRange) {
        this(
                id,
                Player.buildDefaultLifeStateSequence(lives),
                Player.buildDefaultDirectedPositionSequence(position),
                maxBombs,
                bombRange
        );
    }

    /**
     * @return the player's ID
     */
    public PlayerID id() {
        return id;
    }

    /**
     * @return the player's life states
     */
    public Sq<LifeState> lifeStates() {
        return lifeStates;
    }

    /**
     * @return the sequence related to the player's next life
     */
    public Sq<LifeState> statesForNextLife() {
        LifeState dying = new LifeState(lives(), LifeState.State.DYING);
        Sq<LifeState> nextLifeState = Sq.repeat(Ticks.PLAYER_DYING_TICKS, dying);

        int newLives = lives() - 1;

        if (newLives >= 0) {
            LifeState dead = new LifeState(newLives, LifeState.State.DEAD);
            nextLifeState = nextLifeState.concat(Sq.constant(dead));
        } else {
            LifeState invulnerable = new LifeState(newLives, LifeState.State.INVULNERABLE);
            LifeState vulnerable = new LifeState(newLives, LifeState.State.VULNERABLE);

            nextLifeState = nextLifeState.concat(Sq.repeat(Ticks.PLAYER_INVULNERABLE_TICKS, invulnerable));
            nextLifeState = nextLifeState.concat(Sq.constant(vulnerable));

        }
        return nextLifeState;
    }

    /**
     * @return the current life state of the player
     */
    public LifeState lifeState() {
        return lifeStates.head();
    }

    /**
     * @return the current number of lives of the player
     */
    public int lives() {
        return lifeStates.head().lives();
    }

    /**
     * @return true is the player has more than 0 lives
     */
    public boolean isAlive() {
        return lives() >= 0;
    }

    /**
     * @return the directed position sequence of the player
     */
    public Sq<DirectedPosition> directedPositions() {
        return directedPos;
    }

    /**
     * @return the position of the player
     */
    public SubCell position() {
        return directedPos.head().position();
    }

    /**
     * @return the current direction of the player
     */
    public Direction direction() {
        return directedPos.head().direction();
    }

    /**
     * @return the maximum number of bombs that the player can use
     */
    public int maxBombs() {
        return maxBombs;
    }

    /**
     * @return a new Player with the new maximum of bombs
     */
    public Player withMaxBombs(int newMaxBombs) {
        return new Player(id, lifeStates, directedPos, newMaxBombs, bombRange);
    }

    /**
     * @return the range of the player's bomb
     */
    public int bombRange() {
        return bombRange;
    }

    /**
     * @return a new Player with the new bomb range
     */
    public Player withBombRange(int newBombRange) {
        return new Player(id, lifeStates, directedPos, maxBombs, newBombRange);
    }

    /**
     * @return a new bomb posed by the Player
     */
    public Bomb newBomb() {
        return new Bomb(id, position().containingCell(), Ticks.BOMB_FUSE_TICKS, bombRange);
    }

}