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.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.Random; /** 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 executeRequest(GameState state, Request request) { ArrayList 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()); } 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()); } } } /** * 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 getFreeNeighbour(GameState state, IntVector2 start) { ArrayList 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 getFreeFields(GameState state) { ArrayList 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 startGame(GameState state, ArrayList selectedCharacters1, ArrayList selectedCharacters2) { ArrayList result = new ArrayList<>(); ArrayList 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 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 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 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 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 handleTurnEnd(GameState state) { ArrayList result = new ArrayList<>(); ArrayList 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 handleRoundStart(GameState state) { ArrayList result = new ArrayList<>(); state.roundNumber++; state.turnNumber = 0; result.add(new EventBuilder(EventType.RoundSetupEvent) .withRoundCount(state.roundNumber) .buildGameEvent()); ArrayList turns = new ArrayList<>(); if(state.roundNumber >= 1 && state.roundNumber <= 6) { turns.add(new EntityID(EntityType.NPC, NPCType.Goose.getID())); result.addAll(handleGoose(state)); } HashSet 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 handleGoose(GameState state) { ArrayList 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 inventory = new ArrayList<>(state.unvomitedStones); int picked = rand.nextInt(inventory.size()); StoneType stone = inventory.get(picked); inventory.remove(picked); state.unvomitedStones.remove(stone); ArrayList 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 handleStan(GameState state, HashSet revived) { ArrayList 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 characters = new ArrayList<>(); ArrayList 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 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 spawnThanos(GameState state) { ArrayList result = new ArrayList<>(); ArrayList 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 handleThanos(GameState state, NPC thanos) { ArrayList 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 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 handleTurnStart(GameState state) { ArrayList 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 handlePlayerWin(GameState state, EntityType winner) { ArrayList 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 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 rasterize(IntVector2 a, IntVector2 b, boolean includeA, boolean includeB) { ArrayList 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 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 getWireframe(Rectangle.Float rect) { ArrayList 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 Bresenham4Connected(IntVector2 a, IntVector2 b) { ArrayList 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; } }