From c633694222734855660cdc947c85ee12153099b6 Mon Sep 17 00:00:00 2001 From: Chaoscaot Date: Wed, 7 May 2025 16:16:36 +0200 Subject: [PATCH] Refactor event handling and tie-break logic implementation Introduced new methods and structures in EventGroup, EventRelation, and EventFight to streamline point calculations, tie-break detection, and dependency resolution. Improved modularity by adding methods like getLastFight, needsTieBreak, and getDependents while optimizing the event result setting process. This refactor enhances clarity, reduces redundancy, and supports better maintainability of event-related logic. --- .../SQL/src/de/steamwar/sql/EventFight.java | 15 +++++ .../SQL/src/de/steamwar/sql/EventGroup.java | 67 ++++++++++++------- .../src/de/steamwar/sql/EventRelation.java | 59 ++++++++++++++-- .../fightsystem/utils/FightStatistics.java | 17 ++++- 4 files changed, 125 insertions(+), 33 deletions(-) diff --git a/CommonCore/SQL/src/de/steamwar/sql/EventFight.java b/CommonCore/SQL/src/de/steamwar/sql/EventFight.java index c595149b..e231fc70 100644 --- a/CommonCore/SQL/src/de/steamwar/sql/EventFight.java +++ b/CommonCore/SQL/src/de/steamwar/sql/EventFight.java @@ -38,6 +38,7 @@ public class EventFight implements Comparable { private static final Table table = new Table<>(EventFight.class); private static final SelectStatement byId = table.select(Table.PRIMARY); private static final SelectStatement byGroup = new SelectStatement(table, "SELECT * FROM EventFight WHERE GroupID = ? ORDER BY StartTime ASC"); + private static final SelectStatement byGroupLast = new SelectStatement(table, "SELECT * FROM EventFight WHERE GroupID = ? ORDER BY StartTime DESC LIMIT 1"); private static final SelectStatement allComing = new SelectStatement<>(table, "SELECT * FROM EventFight WHERE StartTime > now() ORDER BY StartTime ASC"); private static final SelectStatement event = new SelectStatement<>(table, "SELECT * FROM EventFight WHERE EventID = ? ORDER BY StartTime ASC"); private static final Statement reschedule = table.update(Table.PRIMARY, "StartTime"); @@ -59,6 +60,10 @@ public class EventFight implements Comparable { return byGroup.listSelect(group.getId()); } + public static Optional getLast(EventGroup group) { + return Optional.ofNullable(byGroupLast.select(group.getId())); + } + public static void loadAllComingFights() { fights.clear(); fights.addAll(allComing.listSelect()); @@ -126,6 +131,16 @@ public class EventFight implements Comparable { return Optional.ofNullable(ergebnis == 1 ? Team.get(teamBlue) : Team.get(teamRed)); } + public Optional getLosser() { + if(ergebnis == 0) + return Optional.empty(); + return Optional.ofNullable(ergebnis == 1 ? Team.get(teamRed) : Team.get(teamBlue)); + } + + public List getDependents() { + return EventRelation.getFightRelations(this); + } + public void setErgebnis(int winner) { this.ergebnis = winner; setResult.update(winner, fightID); diff --git a/CommonCore/SQL/src/de/steamwar/sql/EventGroup.java b/CommonCore/SQL/src/de/steamwar/sql/EventGroup.java index 3ea62738..c5c00580 100644 --- a/CommonCore/SQL/src/de/steamwar/sql/EventGroup.java +++ b/CommonCore/SQL/src/de/steamwar/sql/EventGroup.java @@ -71,45 +71,60 @@ public class EventGroup { @Field private int pointsPerDraw; + private Map points; + public List getFights() { return EventFight.get(this); } + public Optional getLastFight() { + return EventFight.getLast(this); + } + + public List getDependents() { + return EventRelation.getGroupRelations(this); + } + public Map calculatePoints() { - Map teams = new HashMap<>(); - Map points = new HashMap<>(); + if (points == null) { + Map teams = new HashMap<>(); - for(EventFight fight : getFights()) { - int blueTeamAdd = 0; - int redTeamAdd = 0; + for(EventFight fight : getFights()) { + int blueTeamAdd = 0; + int redTeamAdd = 0; - switch (fight.getErgebnis()) { - case 1: - blueTeamAdd += pointsPerWin; - redTeamAdd += pointsPerLoss; - break; - case 2: - blueTeamAdd += pointsPerLoss; - redTeamAdd += pointsPerWin; - break; - case 0: - if (fight.getFightID() != 0) { - blueTeamAdd += pointsPerDraw; - redTeamAdd += pointsPerDraw; - } - break; + switch (fight.getErgebnis()) { + case 1: + blueTeamAdd += pointsPerWin; + redTeamAdd += pointsPerLoss; + break; + case 2: + blueTeamAdd += pointsPerLoss; + redTeamAdd += pointsPerWin; + break; + case 0: + if (fight.getFightID() != 0) { + blueTeamAdd += pointsPerDraw; + redTeamAdd += pointsPerDraw; + } + break; + } + + Team blueTeam = teams.computeIfAbsent(fight.getTeamBlue(), Team::get); + Team redTeam = teams.computeIfAbsent(fight.getTeamRed(), Team::get); + + points.put(blueTeam, points.getOrDefault(blueTeam, 0) + blueTeamAdd); + points.put(redTeam, points.getOrDefault(redTeam, 0) + redTeamAdd); } - - Team blueTeam = teams.computeIfAbsent(fight.getTeamBlue(), Team::get); - Team redTeam = teams.computeIfAbsent(fight.getTeamRed(), Team::get); - - points.put(blueTeam, points.getOrDefault(blueTeam, 0) + blueTeamAdd); - points.put(redTeam, points.getOrDefault(redTeam, 0) + redTeamAdd); } return points; } + public boolean needsTieBreak() { + return calculatePoints().values().stream().sorted().limit(2).distinct().count() < 2; + } + public static enum EventGroupType { GROUP_STAGE, ELIMINATION_STAGE diff --git a/CommonCore/SQL/src/de/steamwar/sql/EventRelation.java b/CommonCore/SQL/src/de/steamwar/sql/EventRelation.java index 1c154d56..13b35f02 100644 --- a/CommonCore/SQL/src/de/steamwar/sql/EventRelation.java +++ b/CommonCore/SQL/src/de/steamwar/sql/EventRelation.java @@ -19,13 +19,12 @@ package de.steamwar.sql; -import de.steamwar.sql.internal.Field; -import de.steamwar.sql.internal.SqlTypeMapper; -import de.steamwar.sql.internal.Table; +import de.steamwar.sql.internal.*; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.Setter; +import java.util.List; import java.util.Map; import java.util.Optional; @@ -41,6 +40,30 @@ public class EventRelation { private static final Table table = new Table<>(EventRelation.class); + private static final SelectStatement get = new SelectStatement<>(table, "SELECT * FROM EventRelation WHERE FromType = ? AND FromId = ?"); + private static final SelectStatement byId = new SelectStatement<>(table, "SELECT * FROM EventRelation WHERE id = ?"); + private static final Statement insert = table.insertAll(true); + private static final Statement update = table.update(Table.PRIMARY, "fromType", "fromId", "fromPlace"); + private static final Statement updateTeam = table.update(Table.PRIMARY, "fightTeam"); + private static final Statement delete = table.delete(Table.PRIMARY); + + public static EventRelation get(int id) { + return byId.select(id); + } + + public static List getFightRelations(EventFight fight) { + return get.listSelect(FromType.FIGHT, fight.getFightID()); + } + + public static List getGroupRelations(EventGroup group) { + return get.listSelect(FromType.GROUP, group.getId()); + } + + public static EventRelation create(EventFight fight, FightTeam fightTeam, FromType fromType, int fromId, int fromPlace) { + int id = insert.insertGetKey(fight.getFightID(), fightTeam, fromType, fromId, fromPlace); + return get(id); + } + @Field(keys = Table.PRIMARY) private final int id; @@ -79,9 +102,37 @@ public class EventRelation { } } + public void delete() { + delete.update(id); + } + + public void setUpdateTeam(FightTeam team) { + updateTeam.update(id, team); + this.fightTeam = team; + } + + public void setFromFight(EventFight fight, int place) { + setFrom(fight.getFightID(), place, FromType.FIGHT); + } + + public void setFromGroup(EventGroup group, int place) { + setFrom(group.getId(), place, FromType.GROUP); + } + + private void setFrom(int id, int place, FromType type) { + update.update(id, type, id, place); + this.fromType = type; + this.fromId = id; + this.fromPlace = place; + } + public Optional getAdvancingTeam() { if (fromType == FromType.FIGHT) { - return getFromFight().flatMap(EventFight::getWinner); + if (fromPlace == 1) { + return getFromFight().flatMap(EventFight::getWinner); + } else { + return getFromFight().flatMap(EventFight::getLosser); + } } else if (fromType == FromType.GROUP) { return getFromGroup().map(EventGroup::calculatePoints) .flatMap(points -> points.entrySet().stream() diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FightStatistics.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FightStatistics.java index ae9a56ac..3d6c5cac 100644 --- a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FightStatistics.java +++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FightStatistics.java @@ -33,6 +33,8 @@ import de.steamwar.fightsystem.states.OneShotStateDependent; import de.steamwar.fightsystem.winconditions.Wincondition; import de.steamwar.network.NetworkSender; import de.steamwar.network.packets.common.FightEndsPacket; +import de.steamwar.sql.EventFight; +import de.steamwar.sql.EventRelation; import de.steamwar.sql.SchematicNode; import de.steamwar.sql.SteamwarUser; import lombok.Getter; @@ -70,12 +72,21 @@ public class FightStatistics { } private void setEventResult() { - if (FightSystem.getLastWinner() == null) + if (FightSystem.getLastWinner() == null) { Config.EventKampf.setErgebnis(0); - else if (FightSystem.getLastWinner().isBlue()) + } else if (FightSystem.getLastWinner().isBlue()) { Config.EventKampf.setErgebnis(1); - else + } else { Config.EventKampf.setErgebnis(2); + } + + Config.EventKampf.getDependents().forEach(EventRelation::apply); + + Config.EventKampf.getGroup().ifPresent(group -> { + if (group.getLastFight().map(EventFight::getFightID).orElse(-1) == Config.EventKampf.getFightID() && !group.needsTieBreak()) { + group.getDependents().forEach(EventRelation::apply); + } + }); } private void disable() {