600 lines
27 KiB
Java
600 lines
27 KiB
Java
package uulm.teamname.marvelous.gamelibrary.gamelogic;
|
|
|
|
import uulm.teamname.marvelous.gamelibrary.IntVector2;
|
|
import uulm.teamname.marvelous.gamelibrary.Tuple;
|
|
import uulm.teamname.marvelous.gamelibrary.entities.*;
|
|
import uulm.teamname.marvelous.gamelibrary.entities.Character;
|
|
import uulm.teamname.marvelous.gamelibrary.events.*;
|
|
import uulm.teamname.marvelous.gamelibrary.events.Event;
|
|
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.util.ArrayList;
|
|
|
|
/** Contains game logic handling. */
|
|
class GameLogic {
|
|
/**
|
|
* 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
|
|
*/
|
|
public 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());
|
|
}
|
|
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 character 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;
|
|
Line2D line = new Line2D.Float(data.originField.getX(), data.originField.getY(), data.targetField.getX(), data.targetField.getY());
|
|
for(int i = data.originField.getX(); i <= data.targetField.getX(); i++) {
|
|
for(int j = data.originField.getY(); j <= data.targetField.getY(); j++) {
|
|
var cell = new Rectangle.Float(i - 0.5f, j - 0.5f, 1, 1);
|
|
if(line.intersects(cell)) {
|
|
for(Entity entity: state.entities.findByPosition(data.targetField)) {
|
|
if(entity.id.isSameType(target)) {
|
|
result.add(new EventBuilder(EventType.TakenDamageEvent)
|
|
.withTargetEntity(entity.id)
|
|
.withTargetField(new IntVector2(i, j))
|
|
.withAmount(data.value)
|
|
.buildEntityEvent());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case RealityStone -> {
|
|
if(data.originEntity == data.targetEntity) { // => place stone
|
|
//TODO: use config values
|
|
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.getValue() * 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.max - origin.ap.getValue();
|
|
if(ap < 0) {
|
|
result.add(new EventBuilder(EventType.ConsumedAPEvent)
|
|
.withTargetEntity(data.originEntity)
|
|
.withTargetField(data.originField)
|
|
.withAmount(ap)
|
|
.buildEntityEvent());
|
|
}
|
|
int mp = origin.mp.max - origin.mp.getValue();
|
|
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.max)
|
|
.buildEntityEvent());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case Req -> {
|
|
result.add(buildGameStateEvent(state));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 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((EntityID[])state.turnOrder.toArray())
|
|
.withMapSize(state.mapSize)
|
|
.withActiveCharacter(state.activeCharacter)
|
|
.withStoneCooldowns(state.stoneCooldown.export())
|
|
.withWinCondition(state.won)
|
|
.buildGameStateEvent();
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
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);
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
requireAlive(origin);
|
|
requireAP(origin, 1);
|
|
requireInfinityStone(origin, data.stoneType);
|
|
|
|
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();
|
|
}
|
|
//TODO: mind stone damage check (config) ???????
|
|
}
|
|
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);
|
|
|
|
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(target.hp.getValue() != 0) {
|
|
throw new InvalidRequestException();
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
case 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)) {
|
|
throw new InvalidRequestException();
|
|
}
|
|
try {
|
|
return (Character)entity;
|
|
}catch(Exception ignored) {
|
|
throw new InvalidRequestException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verifies that a {@link Character} is alive.
|
|
*/
|
|
private static void requireAlive(Character entity) throws InvalidRequestException {
|
|
if(entity.hp.getValue() <= 0 || !entity.isActive()) {
|
|
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 {
|
|
//naive code for the win!!! \o/
|
|
//at least its early exit and probably only O(ln(n*m))
|
|
//TODO: implement proper line rasterization algorithm in GameLogic.requireLineOfSight
|
|
Line2D line = new Line2D.Float(start.getX(), start.getY(), end.getX(), end.getY());
|
|
for(int i = start.getX(); i <= end.getX(); i++) {
|
|
for(int j = start.getY(); j <= end.getY(); j++) {
|
|
var cell = new Rectangle.Float(i - 0.5f, j - 0.5f, 1, 1);
|
|
if(line.intersects(cell)) {
|
|
if(state.entities.blocksVision(new IntVector2(i, j))) {
|
|
throw new InvalidRequestException();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
switch(event.type) {
|
|
case DestroyedEntityEvent -> {
|
|
state.entities.removeEntity(((EntityEvent)event).targetEntity);
|
|
}
|
|
case TakenDamageEvent -> {
|
|
((Character)state.entities.findEntity(((CharacterEvent)event).targetEntity)).hp.decreaseValue(((CharacterEvent)event).amount);
|
|
}
|
|
case ConsumedAPEvent -> {
|
|
((Character)state.entities.findEntity(((CharacterEvent)event).targetEntity)).ap.decreaseValue(((CharacterEvent)event).amount);
|
|
}
|
|
case ConsumedMPEvent -> {
|
|
((Character)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 -> {
|
|
(state.entities.findEntity(((CharacterEvent)event).originEntity)).setPosition(((CharacterEvent)event).targetField);
|
|
}
|
|
case ExchangeInfinityStoneEvent -> {
|
|
((Character)state.entities.findEntity(((CharacterEvent)event).originEntity)).inventory.removeStone(((CharacterEvent)event).stoneType);
|
|
((Character)state.entities.findEntity(((CharacterEvent)event).targetEntity)).inventory.addStone(((CharacterEvent)event).stoneType);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Starts end of round handling if necessary.
|
|
* @param state The game state to work on
|
|
* @return The list of resulting {@link Event}s
|
|
*/
|
|
public 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<>();
|
|
}
|
|
|
|
/**
|
|
* 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> order = state.turnOrder;
|
|
ArrayList<EntityID> alive = new ArrayList<>();
|
|
|
|
state.turnNumber++;
|
|
boolean newRound = false;
|
|
|
|
for (EntityID id: order) {
|
|
Character character = ((Character)state.entities.findEntity(id));
|
|
|
|
if(character.hp.getValue() > 0){
|
|
alive.add(id);
|
|
}
|
|
|
|
if(character.inventory.getFreeSlots() == 0) { // no slots => has all infinity stones
|
|
state.won = true;
|
|
result.add(new EventBuilder(EventType.WinEvent)
|
|
.withPlayerWon(character.id.id)
|
|
.buildGameEvent());
|
|
return result;
|
|
}
|
|
}
|
|
|
|
if(alive.isEmpty()) {
|
|
|
|
//thanos win handling
|
|
|
|
}else {
|
|
|
|
int activeIndex = alive.indexOf(state.activeCharacter);
|
|
if(activeIndex == alive.size() - 1) {
|
|
state.activeCharacter = alive.get(0);
|
|
//reached end of turn order, new round
|
|
state.roundNumber++;
|
|
newRound = true;
|
|
}else {
|
|
state.activeCharacter = alive.get(activeIndex + 1);
|
|
}
|
|
Character activeCharacter = (Character)state.entities.findEntity(state.activeCharacter);
|
|
|
|
result.add(new EventBuilder(EventType.ConsumedAPEvent)
|
|
.withTargetEntity(state.activeCharacter)
|
|
.withTargetField(activeCharacter.getPosition())
|
|
.withAmount(activeCharacter.ap.getValue() - activeCharacter.ap.max)
|
|
.buildGameEvent());
|
|
result.add(new EventBuilder(EventType.ConsumedMPEvent)
|
|
.withTargetEntity(state.activeCharacter)
|
|
.withTargetField(activeCharacter.getPosition())
|
|
.withAmount(activeCharacter.mp.getValue() - activeCharacter.mp.max)
|
|
.buildGameEvent());
|
|
result.add(new EventBuilder(EventType.TurnEvent)
|
|
.withTurnCount(alive.size())
|
|
.withNextCharacter(state.activeCharacter)
|
|
.buildGameEvent());
|
|
|
|
}
|
|
|
|
if(newRound) {
|
|
//special round handling
|
|
//shuffle turn order
|
|
/*
|
|
result.add(new EventBuilder(EventType.RoundSetupEvent)
|
|
.buildGameEvent());
|
|
*/
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
}
|