Arakne / Araknemu

 * This file is part of Araknemu.

 *

 * Araknemu is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * Araknemu is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with Araknemu.  If not, see <https://www.gnu.org/licenses/>.

 *

 * Copyright (c) 2017-2019 Vincent Quatrevieux

 */

package fr.quatrevieux.araknemu.game.player;

import fr.quatrevieux.araknemu.core.event.DefaultListenerAggregate;

import fr.quatrevieux.araknemu.core.event.ListenerAggregate;

import fr.quatrevieux.araknemu.data.living.entity.player.Player;

import fr.quatrevieux.araknemu.data.value.Position;

import fr.quatrevieux.araknemu.game.account.GameAccount;

import fr.quatrevieux.araknemu.game.chat.ChannelSet;

import fr.quatrevieux.araknemu.game.chat.ChannelType;

import fr.quatrevieux.araknemu.game.exploration.ExplorationPlayer;

import fr.quatrevieux.araknemu.game.fight.fighter.player.PlayerFighter;

import fr.quatrevieux.araknemu.game.fight.spectator.Spectator;

import fr.quatrevieux.araknemu.game.player.experience.GamePlayerExperience;

import fr.quatrevieux.araknemu.game.player.inventory.LoadedInventory;

import fr.quatrevieux.araknemu.game.player.inventory.PlayerInventory;

import fr.quatrevieux.araknemu.game.player.race.GamePlayerRace;

import fr.quatrevieux.araknemu.game.player.spell.SpellBook;

import fr.quatrevieux.araknemu.game.player.sprite.GamePlayerSpriteInfo;

import fr.quatrevieux.araknemu.game.player.sprite.SpriteInfo;

import fr.quatrevieux.araknemu.network.game.GameSession;

import org.checkerframework.dataflow.qual.Pure;

import java.util.Set;

/**

 * GamePlayer object

 * A player is a logged character, with associated game session

 */

public final class GamePlayer implements PlayerSessionScope {

    private final GameAccount account;

    private final Player entity;

    private final PlayerService service;

    private final GameSession session;

    private final GamePlayerRace race;

    private final Set<ChannelType> channels;

    private final PlayerInventory inventory;

    private final SpriteInfo spriteInfo;

    private final PlayerData data;

    private final Restrictions restrictions;

    private final ListenerAggregate dispatcher = new DefaultListenerAggregate();

    private PlayerSessionScope scope;

    @SuppressWarnings({"assignment", "argument"})

        this.account = account;

        this.entity = entity;

        this.race = race;

        this.session = session;

        this.service = service;

        this.channels = new ChannelSet(entity.channels(), dispatcher);

        this.inventory = inventory.attach(this);

        this.data = new PlayerData(dispatcher, this, entity, spells, experience);

        this.spriteInfo = new GamePlayerSpriteInfo(entity, this.inventory);

        this.restrictions = new Restrictions(session);

        this.scope = this;

        this.data.build();

        this.restrictions.init(this);

    }

    @Override

    public void dispatch(Object event) {

        session.dispatch(event);

    }

    @Override

    @Pure

    public ListenerAggregate dispatcher() {

        return dispatcher;

    }

    /**

     * Get the base player data

     * The data should be used for change the player data

     * This value do not depends of the current player state (exploring / fighting) and should be modified carefully

     */

    @Override

    @Pure

    public PlayerData properties() {

        return data;

    }

    @Override

    public void send(Object packet) {

        session.send(packet);

    }

    @Override

    public void register(GameSession session) {

        session.setPlayer(this);

    }

    @Override

    public void unregister(GameSession session) {

        session.setPlayer(null);

    }

    @Pure

    public int id() {

        return entity.id();

    }

    @Pure

    public GameAccount account() {

        return account;

    }

    /**

     * Get the current player position

     */

    @Pure

    public Position position() {

        return entity.position();

    }

    /**

     * Set new position

     */

    public void setPosition(Position position) {

        entity.setPosition(position);

    }

    /**

     * Get the player saved position (teleport when die)

     */

    @Pure

    public Position savedPosition() {

        return entity.savedPosition();

    }

    /**

     * Set saved position (teleport when die)

     */

    public void setSavedPosition(Position position) {

        entity.setSavedPosition(position);

    }

    /**

     * Get the player race

     */

    @Pure

    public GamePlayerRace race() {

        return race;

    }

    @Pure

    public String name() {

        return entity.name();

    }

    /**

     * Get channels subscriptions

     */

    @Pure

    public Set<ChannelType> subscriptions() {

        return channels;

    }

    /**

     * Get the current session scope

     */

    @Pure

    public PlayerSessionScope scope() {

        return scope;

    }

    /**

     * Start a new session scope

     */

    public void start(PlayerSessionScope scope) {

        if (this.scope == scope) {

            throw new IllegalStateException("Scope already started");

        }

        scope.register(session);

        this.scope = scope;

    }

    /**

     * Stop the scope

     */

    public void stop(PlayerSessionScope scope) {

        scope.unregister(session);

        // Reset the scope only if we stop the active scope

        if (this.scope == scope) {

            this.scope = this;

        }

    }

    /**

     * Check if the player is exploring

     */

    /**

     * Get the exploration player

     *

     * @throws IllegalStateException When the player is not on exploration state

     */

    @Pure

    public ExplorationPlayer exploration() {

        final ExplorationPlayer exploration = session.exploration();

        if (exploration != null) {

            return exploration;

        }

        throw new IllegalStateException("The current player is not an exploration state");

    }

    /**

     * Get the attached fighter

     */

    @Pure

    public PlayerFighter fighter() {

        final PlayerFighter fighter = session.fighter();

        if (fighter != null) {

            return fighter;

        }

        throw new IllegalStateException("The current player is not in fight");

    }

    /**

     * Check if the current player is in fight

     */

    @Pure

    public boolean isFighting() {

        return session.fighter() != null;

    }

    /**

     * Get the attached spectator

     */

    @Pure

    public Spectator spectator() {

        final Spectator spectator = session.spectator();

        if (spectator != null) {

            return spectator;

        }

        throw new IllegalStateException("The current player is not a spectator");

    }

    /**

     * Check if the current player is a spectator

     */

    @Pure

    public boolean isSpectator() {

        return session.spectator() != null;

    }

    /**

     * Save the player

     */

    public void save() {

        properties().life().setLifeWithCurrentRegeneration();

        service.save(this);

    }

    @Pure

    public PlayerInventory inventory() {

        return inventory;

    }

    /**

     * Get the player sprite info

     */

    @Pure

    public SpriteInfo spriteInfo() {

        return spriteInfo;

    }

    /**

     * Get the current player restrictions

     */

    @Pure

    public Restrictions restrictions() {

        return restrictions;

    }

    /**

     * Does the player is a newly created character ? (i.e. first connection)

     */

    public boolean isNew() {

        return session.log().map(log -> !log.hasAlreadyPlayed(entity)).orElse(false);

    }

    @Pure

    Player entity() {

        return entity;

    }

}