Gamelib/src/main/java/uulm/teamname/marvelous/gamelibrary/gamelogic/GameLogic.java

package uulm.teamname.marvelous.gamelibrary.gamelogic;

import uulm.teamname.marvelous.gamelibrary.IntVector2;
import uulm.teamname.marvelous.gamelibrary.entities.Character;
import uulm.teamname.marvelous.gamelibrary.entities.*;
import uulm.teamname.marvelous.gamelibrary.events.Event;
import uulm.teamname.marvelous.gamelibrary.events.*;
import uulm.teamname.marvelous.gamelibrary.config.FieldType;
import uulm.teamname.marvelous.gamelibrary.requests.CharacterRequest;
import uulm.teamname.marvelous.gamelibrary.requests.Request;
import uulm.teamname.marvelous.gamelibrary.requests.RequestType;

import java.awt.*;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.lang.reflect.Array;
import java.util.*;
import java.util.List;

/** Contains game logic handling. */
public class GameLogic {
    private static final Random rand = new Random();

    /**
     * Checks a {@link Request} for validity for a {@link GameState}.
     * @param state The game state to check on
     * @param request The request to validate
     * @return Whether or not the request is valid
     */
    protected static boolean checkRequest(GameState state, Request request) {
        try {
            switch(request.type) {
                case MeleeAttackRequest, RangedAttackRequest -> {
                    CharacterRequest data = (CharacterRequest)request;

                    Character origin = getCharacter(state, data.originField, data.originEntity);
                    Character target = getCharacter(state, data.targetField, data.targetEntity);

                    requireTurn(state, origin);
                    requireOppositeTeam(origin, target);

                    requireAlive(origin);
                    requireAlive(target);
                    requireAP(origin, 1);

                    if(request.type == RequestType.MeleeAttackRequest) {
                        if(origin.meleeDamage != data.value) {
                            throw new InvalidRequestException();
                        }
                        if(data.originField.distanceChebyshev(data.targetField) != 1) {
                            throw new InvalidRequestException();
                        }
                    }else if(request.type == RequestType.RangedAttackRequest) {
                        if(origin.rangedDamage != data.value) {
                            throw new InvalidRequestException();
                        }
                        if(data.originField.distanceChebyshev(data.targetField) > origin.attackRange) {
                            throw new InvalidRequestException();
                        }
                        if(data.originField.distanceChebyshev(data.targetField) <= 1) {
                            throw new InvalidRequestException();
                        }
                        requireLineOfSight(state, data.originField, data.targetField);
                    }

                    return true;
                }
                case MoveRequest -> {
                    CharacterRequest data = (CharacterRequest)request;

                    Character origin = getCharacter(state, data.originField, data.originEntity);

                    requireTurn(state, origin);

                    requireAlive(origin);
                    requireMP(origin, 1);
                    verifyCoordinates(state, data.targetField);

                    if(data.originField.distanceChebyshev(data.targetField) != 1) {
                        throw new InvalidRequestException();
                    }

                    if(state.entities.blocksMovement(data.targetField)) {
                        throw new InvalidRequestException();
                    }

                    return true;
                }
                case ExchangeInfinityStoneRequest -> {
                    CharacterRequest data = (CharacterRequest)request;

                    Character origin = getCharacter(state, data.originField, data.originEntity);
                    Character target = getCharacter(state, data.targetField, data.targetEntity);

                    requireTurn(state, origin);

                    requireAlive(origin);
                    requireAlive(target);
                    requireAP(origin, 1);
                    requireInfinityStone(origin, data.stoneType);

                    if(data.originField.distanceChebyshev(data.targetField) != 1) {
                        throw new InvalidRequestException();
                    }

                    return true;
                }
                case UseInfinityStoneRequest -> {
                    CharacterRequest data = (CharacterRequest)request;

                    Character origin = getCharacter(state, data.originField, data.originEntity);

                    requireTurn(state, origin);

                    requireAlive(origin);
                    requireAP(origin, 1);
                    requireInfinityStone(origin, data.stoneType);

                    if(state.stoneCooldown.onCooldown(data.stoneType)) {
                        throw new InvalidRequestException();
                    }

                    switch(((CharacterRequest) request).stoneType) {
                        case SpaceStone -> {
                            verifyCoordinates(state, data.targetField);

                            if(state.entities.blocksMovement(data.targetField)) {
                                throw new InvalidRequestException();
                            }
                        }
                        case MindStone -> {
                            if(data.originField == data.targetField) {
                                throw new InvalidRequestException();
                            }
                            if(data.value != state.partyConfig.mindStoneDMG) {
                                throw new InvalidRequestException();
                            }
                        }
                        case RealityStone -> {
                            if(data.originEntity == data.targetEntity) { // => place stone
                                if(state.entities.findByPosition(data.targetField).size() != 0) {
                                    throw new InvalidRequestException();
                                }
                            }else { // => destroy stone
                                boolean hasRock = false;
                                for(Entity entity: state.entities.findByPosition(data.targetField)) {
                                    if(entity.id.isSameType(EntityType.Rocks)) {
                                        hasRock = true;
                                        break;
                                    }
                                }
                                if(!hasRock) {
                                    throw new InvalidRequestException();
                                }
                            }
                        }
                        case PowerStone -> {
                            Character target = getCharacter(state, data.targetField, data.targetEntity);

                            requireAlive(target);
                            requireOppositeTeam(origin, target);

                            if(origin.rangedDamage * 2 != data.value) {
                                throw new InvalidRequestException();
                            }
                        }
                        case TimeStone -> {
                            // "👍  i approve" - the server
                        }
                        case SoulStone -> {
                            Character target = getCharacter(state, data.targetField, data.targetEntity);

                            if(data.originEntity == data.targetEntity) {
                                throw new InvalidRequestException();
                            }

                            if(target.isAlive()) {
                                throw new InvalidRequestException();
                            }
                        }
                    }

                    return true;
                }
                case EndRoundRequest, Req -> {
                    return true;
                }
            }
        }catch(Exception ignored) {
            return false;
        }

        return false;
    }

    /**
     * Retrieves a {@link Character} for a {@link Request}.
     * @param state The game state to use
     * @param position The requested position
     * @param entityID The requested {@link EntityID}
     * @return The found character
     * @throws InvalidRequestException if the character is invalid or not found
     */
    private static Character getCharacter(GameState state, IntVector2 position, EntityID entityID) throws InvalidRequestException {
        Entity entity = state.entities.findEntity(entityID);
        if(entity == null || entity.getPosition() != position || !(entity instanceof Character) || entity.id.type == EntityType.NPC) {
            throw new InvalidRequestException();
        }
        try {
            return (Character)entity;
        }catch(Exception ignored) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that a {@link Character} has a turn.
     */
    private static void requireTurn(GameState state, Character entity) throws InvalidRequestException {
        if(entity.id != state.activeCharacter) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that a {@link Character} is of the opposite team of another Character.
     */
    private static void requireOppositeTeam(Character a, Character b) throws InvalidRequestException {
        if(a.id.type == b.id.type) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that a {@link Character} is of the same team of another Character, but not the same.
     */
    private static void requireSameTeam(Character a, Character b) throws InvalidRequestException {
        if(a.id.type != b.id.type || a.id.id == b.id.id) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that a {@link Character} is alive.
     */
    private static void requireAlive(Character entity) throws InvalidRequestException {
        if(!entity.isAlive()) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that a {@link Character} has enough {@link StatType#AP}.
     */
    private static void requireAP(Character entity, int ap) throws InvalidRequestException {
        if(entity.ap.getValue() < ap) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that a {@link Character} has enough {@link StatType#MP}.
     */
    private static void requireMP(Character entity, int mp) throws InvalidRequestException {
        if(entity.mp.getValue() < mp) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that a {@link Character} has the required {@link StoneType}.
     */
    private static void requireInfinityStone(Character entity, StoneType stone) throws InvalidRequestException {
        if(stone == null || !entity.inventory.hasStone(stone)) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that coordinates are within the playing area.
     */
    private static void verifyCoordinates(GameState state, IntVector2 position) throws InvalidRequestException {
        if(position.getX() < 0 || position.getX() >= state.mapSize.getX() || position.getY() < 0 || position.getY() >= state.mapSize.getY()) {
            throw new InvalidRequestException();
        }
    }

    /**
     * Verifies that there is a line of sight between two positions.
     */
    private static void requireLineOfSight(GameState state, IntVector2 start, IntVector2 end) throws InvalidRequestException {
        if(!checkLineOfSight(state, start, end)) {
            throw new InvalidRequestException();
        }
    }


    /**
     * Produces resulting {@link Event}s from a given {@link Request}.
     * @param state The game state to execute on
     * @param request The request to execute
     * @return The list of resulting events
     */
    protected static ArrayList<Event> executeRequest(GameState state, Request request) {
        ArrayList<Event> result = new ArrayList<>();

        switch(request.type) {
            case MeleeAttackRequest, RangedAttackRequest -> {
                CharacterRequest data = (CharacterRequest)request;
                result.add(new EventBuilder(request.type == RequestType.MeleeAttackRequest ? EventType.MeleeAttackEvent : EventType.RangedAttackEvent)
                        .withOriginEntity(data.originEntity)
                        .withTargetEntity(data.targetEntity)
                        .withOriginField(data.originField)
                        .withTargetField(data.targetField)
                        .withAmount(data.value)
                        .buildCharacterEvent());
                result.add(new EventBuilder(EventType.ConsumedAPEvent)
                        .withTargetEntity(data.originEntity)
                        .withTargetField(data.originField)
                        .withAmount(1)
                        .buildEntityEvent());
                result.add(new EventBuilder(EventType.TakenDamageEvent)
                        .withTargetEntity(data.targetEntity)
                        .withTargetField(data.targetField)
                        .withAmount(data.value)
                        .buildEntityEvent());

                Character target = (Character)state.entities.findEntity(data.targetEntity);
                if(target.hp.getValue() <= data.value) {

                    List<StoneType> stones = Arrays.asList(target.inventory.getStonesAsArray());
                    target.inventory.clear();
                    Collections.shuffle(stones); // required by documents

                    for(StoneType stone: stones) {
                        ArrayList<IntVector2> options = getFreeNeighbour(state, target.getPosition());
                        result.add(new EventBuilder(EventType.SpawnEntityEvent)
                                .withEntity(new InfinityStone(
                                        new EntityID(EntityType.InfinityStones, stone.getID()),
                                        options.get(rand.nextInt(options.size())),
                                        stone
                                ))
                                .buildEntityEvent());
                    }
                }
            }
            case MoveRequest -> {
                CharacterRequest data = (CharacterRequest)request;
                result.add(new EventBuilder(EventType.MoveEvent)
                        .withOriginEntity(data.originEntity)
                        .withOriginField(data.originField)
                        .withTargetField(data.targetField)
                        .buildCharacterEvent());
                result.add(new EventBuilder(EventType.ConsumedMPEvent)
                        .withTargetEntity(data.originEntity)
                        .withTargetField(data.targetField) //when this event gets handled, the character already moved to the target field
                        .withAmount(1)
                        .buildEntityEvent());
                for(Entity entity: state.entities.findByPosition(data.targetField)) {
                    if(entity instanceof Character) {
                        result.add(new EventBuilder(EventType.MoveEvent)
                                .withOriginEntity(entity.id)
                                .withOriginField(data.targetField)
                                .withTargetField(data.originField)
                                .buildCharacterEvent());
                        break; //we should only have one entity per field anyways
                    }else if(entity instanceof InfinityStone) {
                        result.add(new EventBuilder(EventType.DestroyedEntityEvent)
                                .withTargetField(data.targetField)
                                .withTargetEntity(entity.id)
                                .buildEntityEvent());
                        break; //we should only have one entity per field anyways
                    }
                }
            }
            case ExchangeInfinityStoneRequest, UseInfinityStoneRequest -> {
                CharacterRequest data = (CharacterRequest)request;
                result.add(new EventBuilder(request.type == RequestType.ExchangeInfinityStoneRequest ? EventType.ExchangeInfinityStoneEvent : EventType.UseInfinityStoneEvent)
                        .withOriginEntity(data.originEntity)
                        .withOriginField(data.originField)
                        .withTargetEntity(data.targetEntity)
                        .withTargetField(data.targetField)
                        .withStoneType(data.stoneType)
                        .buildCharacterEvent());
                result.add(new EventBuilder(EventType.ConsumedAPEvent)
                        .withTargetEntity(data.originEntity)
                        .withTargetField(data.originField)
                        .withAmount(1)
                        .buildEntityEvent());

                if(request.type == RequestType.UseInfinityStoneRequest) {
                    switch(((CharacterRequest) request).stoneType) {
                        case SpaceStone -> {
                            result.add(new EventBuilder(EventType.MoveEvent)
                                    .withOriginEntity(data.originEntity)
                                    .withOriginField(data.originField)
                                    .withTargetField(data.targetField)
                                    .buildCharacterEvent());
                        }
                        case MindStone -> {
                            EntityType target = data.originEntity.type == EntityType.P1 ? EntityType.P2 : EntityType.P1;
                            for(IntVector2 pos: rasterize(data.originField, data.targetField, false, true)) {
                                for(Entity entity: state.entities.findByPosition(pos)) {
                                    if(entity.id.isSameType(target)) {
                                        result.add(new EventBuilder(EventType.TakenDamageEvent)
                                                .withTargetEntity(entity.id)
                                                .withTargetField(pos)
                                                .withAmount(data.value)
                                                .buildEntityEvent());
                                    }
                                }
                            }
                        }
                        case RealityStone -> {
                            if(data.originEntity == data.targetEntity) { // => place stone
                                result.add(new EventBuilder(EventType.SpawnEntityEvent)
                                        .withTargetField(data.targetField)
                                        .withEntity(new Rock(new EntityID(EntityType.Rocks, state.entities.findFreeRockSlot()), data.targetField, 100))
                                        .buildEntityEvent());
                            }else { // => destroy stone
                                result.add(new EventBuilder(EventType.DestroyedEntityEvent)
                                        .withTargetField(data.targetField)
                                        .withTargetEntity(data.targetEntity)
                                        .buildEntityEvent());
                            }
                        }
                        case PowerStone -> {
                            Character origin = (Character)state.entities.findEntity(data.originEntity);
                            int dmg = (int)Math.round(origin.hp.getMax() * 0.1);
                            if(origin.hp.getValue() != 1 && dmg > 0) {
                                result.add(new EventBuilder(EventType.TakenDamageEvent)
                                        .withTargetEntity(data.originEntity)
                                        .withTargetField(data.originField)
                                        .withAmount(dmg)
                                        .buildEntityEvent());
                            }
                            result.add(new EventBuilder(EventType.TakenDamageEvent)
                                    .withTargetEntity(data.targetEntity)
                                    .withTargetField(data.targetField)
                                    .withAmount(data.value)
                                    .buildEntityEvent());
                        }
                        case TimeStone -> {
                            Character origin = (Character)state.entities.findEntity(data.originEntity);
                            int ap = origin.ap.getValue() - origin.ap.getMax();
                            if(ap < 0) {
                                result.add(new EventBuilder(EventType.ConsumedAPEvent)
                                        .withTargetEntity(data.originEntity)
                                        .withTargetField(data.originField)
                                        .withAmount(ap)
                                        .buildEntityEvent());
                            }
                            int mp = origin.mp.getValue() - origin.mp.getMax();
                            if(mp < 0) {
                                result.add(new EventBuilder(EventType.ConsumedMPEvent)
                                        .withTargetEntity(data.originEntity)
                                        .withTargetField(data.originField)
                                        .withAmount(mp)
                                        .buildEntityEvent());
                            }
                        }
                        case SoulStone -> {
                            Character target = (Character)state.entities.findEntity(data.targetEntity);
                            result.add(new EventBuilder(EventType.HealedEvent)
                                    .withTargetEntity(data.targetEntity)
                                    .withTargetField(data.targetField)
                                    .withAmount(target.hp.getMax())
                                    .buildEntityEvent());
                        }
                    }
                }
            }
            case EndRoundRequest -> {
                result.addAll(handleTurnEnd(state)); //why is it called end round request when it ends a turn...
            }
            case Req -> {
                result.add(buildGameStateEvent(state));
            }
        }

        return result;
    }


    /**
     * Applies an {@link Event} to a {@link GameState}.
     * @param state The game state to apply to
     * @param event The event to apply
     */
    protected static void applyEvent(GameState state, Event event) {
        switch(event.type) {
            case DestroyedEntityEvent -> {
                state.entities.removeEntity(((EntityEvent)event).targetEntity);
            }
            case TakenDamageEvent -> {
                Character target = (Character)state.entities.findEntity(((CharacterEvent)event).targetEntity);
                target.hp.decreaseValue(((CharacterEvent)event).amount);

                EntityType opposing = target.id.type == EntityType.P1 ? EntityType.P2 : EntityType.P1;
                state.winConditions.increaseValue(opposing, WinCondition.TotalDamage, ((CharacterEvent)event).amount);
                if(target.hp.getValue() == 0) {
                    state.winConditions.increaseValue(opposing, WinCondition.TotalKnockouts, 1);
                }
            }
            case ConsumedAPEvent -> {
                ((Character)state.entities.findEntity(((CharacterEvent)event).targetEntity)).ap.decreaseValue(((CharacterEvent)event).amount);
            }
            case ConsumedMPEvent -> {
                ((NPC)state.entities.findEntity(((CharacterEvent)event).targetEntity)).mp.decreaseValue(((CharacterEvent)event).amount);
            }
            case SpawnEntityEvent -> {
                state.entities.addEntity(((EntityEvent)event).entity);
            }
            case HealedEvent -> {
                ((Character)state.entities.findEntity(((CharacterEvent)event).targetEntity)).hp.increaseValue(((CharacterEvent)event).amount);
            }
            case MoveEvent -> {
                NPC target = (NPC)state.entities.findEntity(((CharacterEvent)event).originEntity);
                for(Entity entity: state.entities.findByPosition(((CharacterEvent)event).targetField)) {
                    if(entity instanceof InfinityStone) {
                        target.inventory.addStone(((InfinityStone)entity).type);

                        state.winConditions.updateValue(target.id.type, WinCondition.MaxStones, target.inventory.getSize());
                    }
                }
                target.setPosition(((CharacterEvent)event).targetField);
            }
            case UseInfinityStoneEvent -> {
                state.stoneCooldown.setCooldown(((CharacterEvent)event).stoneType);
            }
            case ExchangeInfinityStoneEvent -> {
                ((Character)state.entities.findEntity(((CharacterEvent)event).originEntity)).inventory.removeStone(((CharacterEvent)event).stoneType);
                Character target = (Character)state.entities.findEntity(((CharacterEvent)event).targetEntity);
                target.inventory.addStone(((CharacterEvent)event).stoneType);

                state.winConditions.updateValue(target.id.type, WinCondition.MaxStones, target.inventory.getSize());
            }
            case GamestateEvent -> {
                GamestateEvent data = (GamestateEvent)event;

                state.entities.clear();
                state.entities.addEntities(data.entities);

                state.mapSize.set(data.mapSize);

                state.turnOrder = new ArrayList<>(Arrays.asList(data.turnOrder));

                state.activeCharacter = data.activeCharacter;

                state.stoneCooldown.import_(data.stoneCooldowns);

                state.won = data.winCondition;
            }
        }
    }


    /**
     * Builds a {@link EventType#GamestateEvent} for the given {@link GameState}.
     * @param state The game state to use
     * @return The resulting event
     */
    public static Event buildGameStateEvent(GameState state) {
        return new EventBuilder(EventType.GamestateEvent)
                .withEntities(state.entities.export())
                .withTurnOrder(state.turnOrder.toArray(new EntityID[0]))
                .withMapSize(state.mapSize)
                .withActiveCharacter(state.activeCharacter)
                .withStoneCooldowns(state.stoneCooldown.export())
                .withWinCondition(state.won)
                .buildGameStateEvent();
    }


    /**
     * Checks if a line of sight exists between the two positions
     * @param state The game state to work on
     * @param start The first position
     * @param end The second position
     * @return Whether or not the light of sight exists
     */
    public static boolean checkLineOfSight(GameState state, IntVector2 start, IntVector2 end) {
        for(IntVector2 pos: rasterize(start, end, false, false)) {
            if(state.entities.blocksVision(pos)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Finds free neighbour options from a starting field.
     * @param state The game state to work on
     * @param start The starting position
     * @return A list of free neighbour field options
     */
    public static ArrayList<IntVector2> getFreeNeighbour(GameState state, IntVector2 start) {
        ArrayList<IntVector2> options = new ArrayList<>();

        if(start.getX() < 0 || start.getX() >= state.mapSize.getX() || start.getY() < 0 || start.getY() >= state.mapSize.getY()) {
            return options;
        }

        for(IntVector2 dir: IntVector2.CardinalDirections) {
            if(state.entities.findByPosition(start.add(dir)).size() == 0) {
                options.add(start.add(dir));
            }
        }

        if(options.size() == 0) {
            return getFreeNeighbour(state, start.add(IntVector2.CardinalDirections[rand.nextInt(IntVector2.CardinalDirections.length)]));
        }else {
            return options;
        }
    }

    /**
     * Finds free field options.
     * @param state The game state to work on
     * @return A list of free field options
     */
    public static ArrayList<IntVector2> getFreeFields(GameState state) {
        ArrayList<IntVector2> options = new ArrayList<>();

        for(int x = 0; x < state.mapSize.getX(); x++) {
            for(int y = 0; y < state.mapSize.getY(); y++) {
                IntVector2 pos = new IntVector2(x, y);
                if(state.entities.findByPosition(pos).size() == 0) {
                    options.add(pos);
                }
            }
        }

        return options;
    }


    /**
     * Starts the game and initializes all entities.
     * @param state The game state to work on
     * @param selectedCharacters1 The characters selected by player 1
     * @param selectedCharacters2 The characters selected by player 2
     * @return The list of resulting {@link Event}s
     */
    protected static ArrayList<Event> startGame(GameState state, ArrayList<Integer> selectedCharacters1, ArrayList<Integer> selectedCharacters2) {
        ArrayList<Event> result = new ArrayList<>();

        ArrayList<IntVector2> free = new ArrayList<>();

        int rockIndex = 0;
        for(int x = 0; x < state.mapSize.getX(); x++) {
            for(int y = 0; y < state.mapSize.getY(); y++) {
                if(state.scenarioConfig.scenario[y][x] == FieldType.ROCK) {
                    state.entities.addEntity(new Rock(new EntityID(EntityType.Rocks, rockIndex++), new IntVector2(x, y), 100));
                }else {
                    free.add(new IntVector2(x, y));
                }
            }
        }

        int p1 = selectedCharacters1.size();
        int all = selectedCharacters1.size() + selectedCharacters2.size();

        ArrayList<Integer> characters = new ArrayList<>(selectedCharacters1);
        characters.addAll(selectedCharacters2);

        for(int i = 0; i < all; i++) {
            int choice = rand.nextInt(free.size());
            IntVector2 position = free.get(choice);
            free.remove(choice);

            int selected = characters.get(i);

            EntityID id = new EntityID(i < p1 ? EntityType.P1 : EntityType.P2, i % p1);
            state.entities.addEntity(new Character(
                    id, position,
                    state.characterConfig.characters[selected].name,
                    state.characterConfig.characters[selected].HP,
                    state.characterConfig.characters[selected].MP,
                    state.characterConfig.characters[selected].AP,
                    state.characterConfig.characters[selected].attackRange,
                    state.characterConfig.characters[selected].rangedDamage,
                    state.characterConfig.characters[selected].meleeDamage
            ));

            state.turnOrder.add(id);
        }

        result.add(buildGameStateEvent(state));

        return result;
    }

    /**
     * Forcefully starts the next round.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    protected static ArrayList<Event> startRound(GameState state) {
        return handleRoundStart(state);
    }

    /**
     * Starts end of round handling if necessary.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    protected static ArrayList<Event> checkTurnEnd(GameState state) {
        if(
            ((Character) state.entities.findEntity(state.activeCharacter)).ap.getValue() <= 0 &&
            ((Character) state.entities.findEntity(state.activeCharacter)).mp.getValue() <= 0
        ) {
            return handleTurnEnd(state);
        }

        return new ArrayList<>();
    }

    /**
     * Forcefully ends the current turn.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    protected static ArrayList<Event> endTurn(GameState state) {
        return handleTurnEnd(state);
    }


    /**
     * Handles everything that happens at the end of a turn, including new rounds.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    private static ArrayList<Event> handleTurnEnd(GameState state) {
        ArrayList<Event> result = new ArrayList<>();

        ArrayList<EntityID> alive = new ArrayList<>();

        for (EntityID id: state.turnOrder) {
            if(id.type == EntityType.NPC) {
                continue;
            }

            Character character = ((Character)state.entities.findEntity(id));

            if(character.isAlive()){
                alive.add(id);
            }else { // send empty turn for knocked out characters
                result.add(new EventBuilder(EventType.TurnEvent)
                        .withTurnCount(state.turnOrder.size())
                        .withNextCharacter(id)
                        .buildGameEvent());
            }

            if(character.inventory.getFreeSlots() == 0) { // no slots => has all infinity stones
                result.addAll(handlePlayerWin(state, character.id.type));
                return result;
            }
        }

        if(alive.isEmpty()) {
            EntityType winner = state.winConditions.getWinner();
            if(winner == EntityType.None) {
                winner = rand.nextBoolean() ? EntityType.P1 : EntityType.P2;
            }
            result.addAll(handlePlayerWin(state, winner));
            return result;
        }

        int index = alive.indexOf(state.activeCharacter);
        if(index == alive.size() - 1) {
            result.addAll(handleRoundStart(state));
        }else {
            state.activeCharacter = alive.get(index + 1);
        }

        result.addAll(handleTurnStart(state));

        return result;
    }

    /**
     * Handles everything that happens at the beginning of new rounds.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    private static ArrayList<Event> handleRoundStart(GameState state) {
        ArrayList<Event> result = new ArrayList<>();

        state.roundNumber++;
        state.turnNumber = 0;

        result.add(new EventBuilder(EventType.RoundSetupEvent)
                .withRoundCount(state.roundNumber)
                .buildGameEvent());

        ArrayList<EntityID> turns = new ArrayList<>();

        if(state.roundNumber >= 1 && state.roundNumber <= 6) {
            turns.add(new EntityID(EntityType.NPC, NPCType.Goose.getID()));
            result.addAll(handleGoose(state));
        }

        HashSet<EntityID> revived = new HashSet<>();
        if(state.roundNumber == 7) {
            turns.add(new EntityID(EntityType.NPC, NPCType.Stan.getID()));
            result.addAll(handleStan(state, revived));
        }

        if(state.roundNumber == state.partyConfig.maxRounds + 1) {
            turns.add(new EntityID(EntityType.NPC, NPCType.Thanos.getID()));
            result.addAll(spawnThanos(state));
        }

        Collections.shuffle(state.turnOrder);

        for (EntityID id: state.turnOrder) {
            if(id.type == EntityType.NPC || revived.contains(id) || ((Character)state.entities.findEntity(id)).hp.getValue() > 0){
                state.activeCharacter = id;
                break;
            }else { // again send empty turns for knocked out characters
                result.add(new EventBuilder(EventType.TurnEvent)
                        .withTurnCount(state.turnOrder.size())
                        .withNextCharacter(id)
                        .buildGameEvent());
            }
        }

        state.stoneCooldown.update();

        turns.addAll(state.turnOrder);

        // RoundSetupEvent has to be sent first, but the contents of it are determined later...
        ((GameEvent)result.get(0)).characterOrder = turns.toArray(new EntityID[0]);

        return result;
    }

    /**
     * Handles the actions of Goose at rounds 1-6.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    private static ArrayList<Event> handleGoose(GameState state) {
        ArrayList<Event> result = new ArrayList<>();

        EntityID goose = new EntityID(EntityType.NPC, NPCType.Goose.getID());

        result.add(new EventBuilder(EventType.TurnEvent)
                .withTurnCount(state.turnOrder.size())
                .withNextCharacter(goose)
                .buildGameEvent());

        ArrayList<StoneType> inventory = new ArrayList<>(state.unvomitedStones);
        int picked = rand.nextInt(inventory.size());
        StoneType stone = inventory.get(picked);
        inventory.remove(picked);
        state.unvomitedStones.remove(stone);

        ArrayList<IntVector2> free = new ArrayList<>();
        for(int x = 0; x < state.mapSize.getX(); x++) {
            for(int y = 0; y < state.mapSize.getY(); y++) {
                IntVector2 pos = new IntVector2(x, y);
                if(state.entities.findByPosition(pos).size() == 0) {
                    free.add(pos);
                }
            }
        }
        IntVector2 position = free.get(rand.nextInt(free.size()));

        result.add(new EventBuilder(EventType.SpawnEntityEvent)
                .withEntity(new NPC(goose, position, inventory))
                .buildEntityEvent());
        result.add(new EventBuilder(EventType.SpawnEntityEvent)
                .withEntity(new InfinityStone(new EntityID(EntityType.InfinityStones, stone.getID()), position, stone))
                .buildEntityEvent());
        result.add(new EventBuilder(EventType.DestroyedEntityEvent)
                .withTargetEntity(goose)
                .withTargetField(position)
                .buildEntityEvent());

        return result;
    }

    /**
     * Handles the actions of Stan at round 7.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    private static ArrayList<Event> handleStan(GameState state, HashSet<EntityID> revived) {
        ArrayList<Event> result = new ArrayList<>();

        EntityID stan = new EntityID(EntityType.NPC, NPCType.Stan.getID());

        result.add(new EventBuilder(EventType.TurnEvent)
                .withTurnCount(state.turnOrder.size())
                .withNextCharacter(stan)
                .buildGameEvent());

        ArrayList<Character> characters = new ArrayList<>();

        ArrayList<IntVector2> targetOptions = new ArrayList<>();
        int lowest = -1;
        for(EntityID id: state.turnOrder) {
            Character character = (Character)state.entities.findEntity(id);
            characters.add(character);

            if(lowest == -1 || character.hp.getValue() < lowest) {
                lowest = character.hp.getValue();
                targetOptions.clear();
            }
            if(lowest == character.hp.getValue()) {
                targetOptions.add(character.getPosition());
            }
        }
        IntVector2 targetPosition = targetOptions.get(rand.nextInt(targetOptions.size()));

        ArrayList<IntVector2> spawnOptions = getFreeNeighbour(state, targetPosition);
        if(spawnOptions.size() == 0) {
            return result;
        }
        IntVector2 spawnPosition = spawnOptions.get(rand.nextInt(spawnOptions.size()));

        result.add(new EventBuilder(EventType.SpawnEntityEvent)
                .withEntity(new NPC(stan, spawnPosition))
                .buildEntityEvent());

        for(Character character: characters) {
            if(checkLineOfSight(state, spawnPosition, character.getPosition())) {
                if(character.hp.getValue() == 0) {
                    revived.add(character.id);
                }
                if(character.hp.getValue() != character.hp.getMax()) {
                    result.add(new EventBuilder(EventType.HealedEvent)
                            .withTargetEntity(character.id)
                            .withTargetField(character.getPosition())
                            .withAmount(character.hp.getMax() - character.hp.getValue())
                            .buildEntityEvent());
                }
            }
        }

        result.add(new EventBuilder(EventType.DestroyedEntityEvent)
                .withTargetEntity(stan)
                .withTargetField(spawnPosition)
                .buildEntityEvent());

        return result;
    }

    /**
     * Spawns Thanos at the beginning of the first overtime round.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    private static ArrayList<Event> spawnThanos(GameState state) {
        ArrayList<Event> result = new ArrayList<>();

        ArrayList<IntVector2> free = getFreeFields(state);
        IntVector2 position = free.get(rand.nextInt(free.size()));

        int maxMP = -1;
        for(EntityID id: state.turnOrder) {
            Character character = (Character)state.entities.findEntity(id);

            if(character.mp.getMax() > maxMP) {
                maxMP = character.mp.getMax();
            }
        }

        EntityID thanos = new EntityID(EntityType.NPC, NPCType.Thanos.getID());
        result.add(new EventBuilder(EventType.SpawnEntityEvent)
                .withEntity(new NPC(thanos, position, maxMP))
                .buildEntityEvent());

        state.turnOrder.add(thanos);

        return result;
    }

    /**
     * Handles Thanos' AI.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    private static ArrayList<Event> handleThanos(GameState state, NPC thanos) {
        ArrayList<Event> result = new ArrayList<>();

        result.add(new EventBuilder(EventType.TurnEvent)
                .withTurnCount(state.turnOrder.size())
                .withNextCharacter(thanos.id)
                .buildGameEvent());

        if(thanos.inventory.getFreeSlots() > 0) {

            IntVector2 picked = null;
            float lowestDistance = Integer.MAX_VALUE;
            for(int x = 0; x < state.mapSize.getX(); x++) {
                for(int y = 0; y < state.mapSize.getY(); y++) {
                    IntVector2 pos = new IntVector2(x, y);
                    for(Entity e: state.entities.findByPosition(pos)) {
                        if(e instanceof InfinityStone || (e instanceof Character && ((Character)e).inventory.getSize() > 0)) {
                            float distance = thanos.getPosition().distanceChebyshev(pos);
                            if(distance < lowestDistance) {
                                picked = pos;
                                lowestDistance = distance;
                                break;
                            }
                        }
                    }
                }
            }

            if(picked == null) {
                return result;
            }

            ArrayList<IntVector2> path = GameLogic.Bresenham4Connected(thanos.getPosition(), picked);

            int mp = thanos.mp.getValue();

            if(mp <= 0) {
                return result;
            }

            IntVector2 current = thanos.getPosition();
            for(IntVector2 pos: path) {
                if(pos.equals(thanos.getPosition())) {
                    continue;
                }

                if(!pos.equals(picked)) {
                    for(Entity entity: state.entities.findByPosition(pos)) {
                        if(entity instanceof Rock) {
                            result.add(new EventBuilder(EventType.DestroyedEntityEvent)
                                    .withTargetEntity(entity.id)
                                    .withTargetField(entity.getPosition())
                                    .buildEntityEvent());
                        }
                    }
                }

                result.add(new EventBuilder(EventType.MoveEvent)
                        .withOriginEntity(thanos.id)
                        .withOriginField(current)
                        .withTargetField(pos)
                        .buildCharacterEvent());
                result.add(new EventBuilder(EventType.ConsumedMPEvent)
                        .withTargetEntity(thanos.id)
                        .withTargetField(pos)
                        .withAmount(1)
                        .buildCharacterEvent());

                if(pos.equals(picked)) {
                    for(Entity entity: state.entities.findByPosition(pos)) {
                        if(entity instanceof Character) {
                            result.add(new EventBuilder(EventType.MoveEvent)
                                    .withOriginEntity(entity.id)
                                    .withOriginField(pos)
                                    .withTargetField(current)
                                    .buildCharacterEvent());
                            result.add(new EventBuilder(EventType.TakenDamageEvent)
                                    .withTargetEntity(entity.id)
                                    .withTargetField(current)
                                    .withAmount(((Character)entity).hp.getValue())
                                    .buildEntityEvent());
                            ((Character)entity).inventory.transfer(thanos.inventory);
                            break;
                        }
                        if(entity instanceof InfinityStone) {
                            break;
                        }
                    }
                }

                current = pos;
                if(--mp == 0) {
                    break;
                }
            }

        }else {

            for(EntityID id: state.turnOrder) {
                if(id.equals(thanos.id)) {
                    continue;
                }
                if(rand.nextBoolean()) {
                    result.add(new EventBuilder(EventType.DestroyedEntityEvent)
                            .withTargetEntity(id)
                            .withTargetField(state.entities.findEntity(id).getPosition())
                            .buildEntityEvent());
                }
            }

        }

        return result;
    }

    /**
     * Handles everything that happens at the beginning of a turn.
     * @param state The game state to work on
     * @return The list of resulting {@link Event}s
     */
    private static ArrayList<Event> handleTurnStart(GameState state) {
        ArrayList<Event> result = new ArrayList<>();

        state.turnNumber++;

        if(state.activeCharacter.type == EntityType.NPC && state.activeCharacter.id == NPCType.Thanos.getID()) {
            NPC thanos = (NPC)state.entities.findEntity(state.activeCharacter);

            if(state.roundNumber > state.partyConfig.maxRounds + 1) {
                thanos.mp.setMax(thanos.mp.getMax() + 1);//TODO: use event for this...
            }

            if(thanos.mp.getValue() != thanos.mp.getMax()) {
                result.add(new EventBuilder(EventType.ConsumedMPEvent)
                        .withTargetEntity(state.activeCharacter)
                        .withTargetField(thanos.getPosition())
                        .withAmount(thanos.mp.getValue() - thanos.mp.getMax())
                        .buildGameEvent());
                thanos.mp.setValue(thanos.mp.getMax());
            }
            result.addAll(handleThanos(state, thanos));

            return result;
        }

        Character activeCharacter = (Character)state.entities.findEntity(state.activeCharacter);

        if(activeCharacter.ap.getValue() != activeCharacter.ap.getMax()) {
            result.add(new EventBuilder(EventType.ConsumedAPEvent)
                    .withTargetEntity(state.activeCharacter)
                    .withTargetField(activeCharacter.getPosition())
                    .withAmount(activeCharacter.ap.getValue() - activeCharacter.ap.getMax())
                    .buildGameEvent());
        }
        if(activeCharacter.mp.getValue() != activeCharacter.mp.getMax()) {
            result.add(new EventBuilder(EventType.ConsumedMPEvent)
                    .withTargetEntity(state.activeCharacter)
                    .withTargetField(activeCharacter.getPosition())
                    .withAmount(activeCharacter.mp.getValue() - activeCharacter.mp.getMax())
                    .buildGameEvent());
        }
        result.add(new EventBuilder(EventType.TurnEvent)
                .withTurnCount(state.turnOrder.size())
                .withNextCharacter(state.activeCharacter)
                .buildGameEvent());

        return result;
    }

    /**
     * Handles the victory of a player through one character.
     * @param state The game state to work on
     * @param winner The winning character
     * @return The list of resulting {@link Event}s
     */
    private static ArrayList<Event> handlePlayerWin(GameState state, EntityType winner) {
        ArrayList<Event> result = new ArrayList<>();

        state.won = true;

        result.add(new EventBuilder(EventType.WinEvent)
                .withPlayerWon(winner == EntityType.P1 ? 1 : 2)
                .buildGameEvent());

        return result;
    }


    /**
     * Computes all fields which intersect the line between the center points of the given two fields including the two defining points.
     * @return The list of intersecting positions
     */
    public static ArrayList<IntVector2> rasterize(IntVector2 a, IntVector2 b) {
        return rasterize(a, b, true, true);
    }

    /**
     * Computes all fields which intersect the line between the center points of the given two fields.
     * @param includeA Whether to include point a in the result
     * @param includeB Whether to include point b in the result
     * @return The list of intersecting positions
     */
    public static ArrayList<IntVector2> rasterize(IntVector2 a, IntVector2 b, boolean includeA, boolean includeB) {
        ArrayList<IntVector2> result = new ArrayList<>();

        int x1 = Math.min(a.getX(), b.getX());
        int x2 = Math.max(a.getX(), b.getX());
        int y1 = Math.min(a.getY(), b.getY());
        int y2 = Math.max(a.getY(), b.getY());

        Line2D line = new Line2D.Float(x1 + 0.5f, y1 + 0.5f, x2 + 0.5f, y2 + 0.5f);
        for(int i = x1; i <= x2; i++) {
            for(int j = y1; j <= y2; j++) {
                HashSet<Point2D.Float> intersections = new HashSet<>();
                for(Line2D.Float part: getWireframe(new Rectangle.Float(i, j, 1, 1))) {
                    if(part.intersectsLine(line)) {
                        Point2D.Float intersection = calculateInterceptionPoint(line.getP1(), line.getP2(), part.getP1(), part.getP2());
                        intersections.add(intersection);
                        if(intersections.size() > 1) {
                            break;
                        }
                    }
                }
                if(intersections.size() > 1) {
                    result.add(new IntVector2(i, j));
                }
            }
        }

        if(includeA) {
            result.add(a);
        }
        if(includeB) {
            result.add(b);
        }

        return result;
    }

    //https://rosettacode.org/wiki/Find_the_intersection_of_two_lines#Java
    public static Point2D.Float calculateInterceptionPoint(Point2D s1, Point2D s2, Point2D d1, Point2D d2) {
        double a1 = s2.getY() - s1.getY();
        double b1 = s1.getX() - s2.getX();
        double c1 = a1 * s1.getX() + b1 * s1.getY();

        double a2 = d2.getY() - d1.getY();
        double b2 = d1.getX() - d2.getX();
        double c2 = a2 * d1.getX() + b2 * d1.getY();

        double delta = a1 * b2 - a2 * b1;
        return new Point2D.Float((float) ((b2 * c1 - b1 * c2) / delta), (float) ((a1 * c2 - a2 * c1) / delta));
    }

    /** Computes all wireframe lines for the given rectangle. */
    public static ArrayList<Line2D.Float> getWireframe(Rectangle.Float rect) {
        ArrayList<Line2D.Float> result = new ArrayList<>();

        Point2D.Float lt = new Point2D.Float(rect.x, rect.y);
        Point2D.Float rt = new Point2D.Float(rect.x + rect.width, rect.y);
        Point2D.Float rb = new Point2D.Float(rect.x + rect.width, rect.y + rect.height);
        Point2D.Float lb = new Point2D.Float(rect.x, rect.y + rect.height);

        result.add(new Line2D.Float(lt, rt));
        result.add(new Line2D.Float(rt, rb));
        result.add(new Line2D.Float(lb, rb));
        result.add(new Line2D.Float(lt, lb));

        return result;
    }

    //https://stackoverflow.com/a/5187612
    public static ArrayList<IntVector2> Bresenham4Connected(IntVector2 a, IntVector2 b) {
        ArrayList<IntVector2> result = new ArrayList<>();

        int x0 = a.getX();
        int y0 = a.getY();
        int x1 = b.getX();
        int y1 = b.getY();

        int dx = Math.abs(x1 - x0);
        int dy = Math.abs(y1 - y0);

        int ix = x0 < x1 ? 1 : -1;
        int iy = y0 < y1 ? 1 : -1;

        int e = 0;

        for(int i = 0; i < dx + dy; i++) {
            result.add(new IntVector2(x0, y0));
            int e1 = e + dy;
            int e2 = e - dx;
            if(Math.abs(e1) < Math.abs(e2)) {
                x0 += ix;
                e = e1;
            }else {
                y0 += iy;
                e = e2;
            }
        }

        result.add(b);

        return result;
    }
}