276 lines
12 KiB
Java
276 lines
12 KiB
Java
package uulm.teamname.marvelous.gamelibrary.gamelogic;
|
|
|
|
import uulm.teamname.marvelous.gamelibrary.Tuple;
|
|
import uulm.teamname.marvelous.gamelibrary.entities.Entity;
|
|
import uulm.teamname.marvelous.gamelibrary.entities.Character;
|
|
import uulm.teamname.marvelous.gamelibrary.events.*;
|
|
import uulm.teamname.marvelous.gamelibrary.requests.CharacterRequest;
|
|
import uulm.teamname.marvelous.gamelibrary.requests.Request;
|
|
import uulm.teamname.marvelous.gamelibrary.requests.RequestType;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
/** Contains game logic handling. */
|
|
class GameLogic {
|
|
/**
|
|
* Produces resulting {@link Event}s from a given {@link Request} independently of any {@link GameState}.
|
|
* @return The list of resulting events
|
|
*/
|
|
public static ArrayList<Event> executeRequest(Request request) {
|
|
ArrayList<Event> result = new ArrayList<>();
|
|
|
|
switch(request.type) {
|
|
case MeleeAttackRequest, RangedAttackRequest -> {
|
|
CharacterRequest data = (CharacterRequest)request;
|
|
result.add(new CharacterEvent()
|
|
.setOriginEntity(data.originEntity)
|
|
.setTargetEntity(data.targetEntity)
|
|
.setOriginField(data.originField)
|
|
.setTargetField(data.targetField)
|
|
.setAmount(data.value)
|
|
.type(request.type == RequestType.MeleeAttackRequest ? EventType.MeleeAttackEvent : EventType.RangedAttackEvent));
|
|
result.add(new EntityEvent()
|
|
.setTargetEntity(data.originEntity)
|
|
.setTargetField(data.originField)
|
|
.setAmount(1)
|
|
.type(EventType.ConsumedAPEvent));
|
|
result.add(new EntityEvent()
|
|
.setTargetEntity(data.targetEntity)
|
|
.setTargetField(data.targetField)
|
|
.setAmount(data.value)
|
|
.type(EventType.TakenDamageEvent));
|
|
}
|
|
case MoveRequest -> {
|
|
CharacterRequest data = (CharacterRequest)request;
|
|
result.add(new CharacterEvent()
|
|
.setOriginEntity(data.originEntity)
|
|
.setOriginField(data.originField)
|
|
.setTargetField(data.targetField)
|
|
.type(EventType.MoveEvent));
|
|
result.add(new EntityEvent()
|
|
.setTargetEntity(data.originEntity)
|
|
.setTargetField(data.targetField) //when this event gets handled, the character already moved to the target field
|
|
.setAmount(1)
|
|
.type(EventType.ConsumedMPEvent));
|
|
//TODO: execute character swap in GameLogic.executeRequest
|
|
}
|
|
case ExchangeInfinityStoneRequest, UseInfinityStoneRequest -> {
|
|
CharacterRequest data = (CharacterRequest)request;
|
|
result.add(new CharacterEvent()
|
|
.setOriginEntity(data.originEntity)
|
|
.setTargetEntity(data.targetEntity)
|
|
.setOriginField(data.originField)
|
|
.setTargetField(data.targetField)
|
|
.setStone(data.stoneType)
|
|
.type(request.type == RequestType.ExchangeInfinityStoneRequest ? EventType.ExchangeInfinityStoneEvent : EventType.UseInfinityStoneEvent));
|
|
result.add(new EntityEvent()
|
|
.setTargetEntity(data.originEntity)
|
|
.setTargetField(data.originField)
|
|
.setAmount(1)
|
|
.type(EventType.ConsumedAPEvent));
|
|
|
|
}
|
|
case DisconnectRequest -> {
|
|
result.add(new GameEvent()
|
|
.type(EventType.DisconnectEvent));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
public static boolean checkRequest(GameState state, Request request) {
|
|
//TODO: refactor this using errors
|
|
try {
|
|
switch(request.type) {
|
|
case MeleeAttackRequest, RangedAttackRequest -> {
|
|
CharacterRequest data = (CharacterRequest)request;
|
|
|
|
Entity originEntity = state.entities.findEntity(data.originEntity);
|
|
if(originEntity == null || originEntity.getPosition() != data.originField || !(originEntity instanceof Character)) {
|
|
return false;
|
|
}
|
|
Character origin = (Character)originEntity;
|
|
Entity targetEntity = state.entities.findEntity(data.targetEntity);
|
|
if(targetEntity == null || targetEntity.getPosition() != data.targetField || !(targetEntity instanceof Character)) {
|
|
return false;
|
|
}
|
|
Character target = (Character)targetEntity;
|
|
|
|
if(origin.hp.getValue() <= 0 || !origin.isActive()) {
|
|
return false;
|
|
}
|
|
if(origin.ap.getValue() < 1) {
|
|
return false;
|
|
}
|
|
if(request.type == RequestType.MeleeAttackRequest && origin.meleeDamage != data.value) {
|
|
return false;
|
|
}else if(request.type == RequestType.RangedAttackRequest && origin.rangedDamage != data.value) {
|
|
return false;
|
|
}
|
|
if(target.hp.getValue() <= 0 || !target.isActive()) {
|
|
return false;
|
|
}
|
|
|
|
if(request.type == RequestType.RangedAttackRequest && origin.getPosition().distance(target.getPosition()) > origin.attackRange) {
|
|
return false;
|
|
}
|
|
|
|
//TODO: check line of sight in GameLogic.checkRequest
|
|
|
|
return true;
|
|
}
|
|
case MoveRequest -> {
|
|
CharacterRequest data = (CharacterRequest)request;
|
|
|
|
Entity originEntity = state.entities.findEntity(data.originEntity);
|
|
if(originEntity == null || originEntity.getPosition() != data.originField || !(originEntity instanceof Character)) {
|
|
return false;
|
|
}
|
|
Character origin = (Character)originEntity;
|
|
|
|
if(data.targetField.getX() < 0 || data.targetField.getX() >= state.mapSize.getX() || data.targetField.getY() < 0 || data.targetField.getY() >= state.mapSize.getY()) {
|
|
return false;
|
|
}
|
|
|
|
for(Entity entity: state.entities.findByPosition(data.targetField)) {
|
|
if(entity.blocksMovement()) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(origin.hp.getValue() <= 0 || !origin.isActive()) {
|
|
return false;
|
|
}
|
|
if(origin.mp.getValue() < 1) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
case ExchangeInfinityStoneRequest -> {
|
|
CharacterRequest data = (CharacterRequest)request;
|
|
|
|
Entity originEntity = state.entities.findEntity(data.originEntity);
|
|
if(originEntity == null || originEntity.getPosition() != data.originField || !(originEntity instanceof Character)) {
|
|
return false;
|
|
}
|
|
Character origin = (Character)originEntity;
|
|
Entity targetEntity = state.entities.findEntity(data.targetEntity);
|
|
if(targetEntity == null || targetEntity.getPosition() != data.targetField || !(targetEntity instanceof Character)) {
|
|
return false;
|
|
}
|
|
Character target = (Character)targetEntity;
|
|
|
|
if(origin.hp.getValue() <= 0 || !origin.isActive()) {
|
|
return false;
|
|
}
|
|
if(origin.ap.getValue() < 1) {
|
|
return false;
|
|
}
|
|
if(target.hp.getValue() <= 0 || !target.isActive()) {
|
|
return false;
|
|
}
|
|
|
|
if(!origin.inventory.hasStone(data.stoneType)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
case UseInfinityStoneRequest -> {
|
|
CharacterRequest data = (CharacterRequest)request;
|
|
|
|
Entity originEntity = state.entities.findEntity(data.originEntity);
|
|
if(originEntity == null || originEntity.getPosition() != data.originField || !(originEntity instanceof Character)) {
|
|
return false;
|
|
}
|
|
Character origin = (Character)originEntity;
|
|
Entity targetEntity = state.entities.findEntity(data.targetEntity);
|
|
if(targetEntity == null || targetEntity.getPosition() != data.targetField || !(targetEntity instanceof Character)) {
|
|
return false;
|
|
}
|
|
Character target = (Character)targetEntity;
|
|
|
|
if(origin.hp.getValue() <= 0 || !origin.isActive()) {
|
|
return false;
|
|
}
|
|
if(origin.ap.getValue() < 1) {
|
|
return false;
|
|
}
|
|
if(!target.isActive()) {
|
|
return false;
|
|
}
|
|
|
|
if(!origin.inventory.hasStone(data.stoneType)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
case DisconnectRequest -> {
|
|
//TODO: add check for DisconnectRequest in GameLogic.checkRequest
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}catch(Exception e) {
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Applies an {@link Event} to a {@link GameState}.
|
|
* @param state The game state to apply to
|
|
* @param event The event to apply
|
|
*/
|
|
public static void applyEvent(GameState state, Event event) {
|
|
//TODO: implement GameLogic.applyEvent
|
|
}
|
|
|
|
/**
|
|
* Checks a {@link GameState} for the current overtime win condition.
|
|
* @param state The game state to check
|
|
* @return The {@link ParticipantType} that is currently winning the game according to overtime ruling
|
|
*/
|
|
public static ParticipantType checkWinConditions(GameState state) {
|
|
//TODO: GameLogic.checkWinConditions is kind of ugly
|
|
|
|
Tuple<ParticipantType, WinCondition> player1;
|
|
Tuple<ParticipantType, WinCondition> player2;
|
|
int value1;
|
|
int value2;
|
|
for(WinCondition condition: WinCondition.values()) {
|
|
player1 = new Tuple<ParticipantType, WinCondition>(ParticipantType.Player1, condition);
|
|
player2 = new Tuple<ParticipantType, WinCondition>(ParticipantType.Player2, condition);
|
|
value1 = 0;
|
|
value2 = 0;
|
|
|
|
if(state.winConditions.containsKey(player1)) {
|
|
value1 = state.winConditions.get(player1);
|
|
}
|
|
if(state.winConditions.containsKey(player2)) {
|
|
value2 = state.winConditions.get(player2);
|
|
}
|
|
|
|
if(value1 > value2) {
|
|
return ParticipantType.Player1;
|
|
}
|
|
if(value2 > value1) {
|
|
return ParticipantType.Player2;
|
|
}
|
|
}
|
|
|
|
return ParticipantType.None;
|
|
}
|
|
}
|