From 19b27d11fc07f79c386317f8a0f2e71d69f21a4a Mon Sep 17 00:00:00 2001 From: Adam Date: Sun, 27 Oct 2019 18:45:13 -0400 Subject: [PATCH] raids plugin: refactor RaidRoom --- .../runelite/client/plugins/raids/Raid.java | 41 +---- .../client/plugins/raids/RaidRoom.java | 159 +++--------------- .../client/plugins/raids/RaidsOverlay.java | 16 +- .../client/plugins/raids/RaidsPlugin.java | 69 +++----- .../client/plugins/raids/RoomType.java | 80 +++++++++ .../raids/{solver => }/RotationSolver.java | 67 +++----- .../plugins/raids/RotationSolverTest.java | 72 ++++++++ 7 files changed, 241 insertions(+), 263 deletions(-) create mode 100644 runelite-client/src/main/java/net/runelite/client/plugins/raids/RoomType.java rename runelite-client/src/main/java/net/runelite/client/plugins/raids/{solver => }/RotationSolver.java (57%) create mode 100644 runelite-client/src/test/java/net/runelite/client/plugins/raids/RotationSolverTest.java diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/raids/Raid.java b/runelite-client/src/main/java/net/runelite/client/plugins/raids/Raid.java index a0baabe691..4f537eb44e 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/raids/Raid.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/raids/Raid.java @@ -60,19 +60,8 @@ public class Raid if (room == null) { - RaidRoom.Type type = RaidRoom.Type.fromCode(layout.getRoomAt(i).getSymbol()); - room = new RaidRoom(null, type); - - if (type == RaidRoom.Type.COMBAT) - { - room.setBoss(RaidRoom.Boss.UNKNOWN); - } - - if (type == RaidRoom.Type.PUZZLE) - { - room.setPuzzle(RaidRoom.Puzzle.UNKNOWN); - } - + RoomType type = RoomType.fromCode(layout.getRoomAt(i).getSymbol()); + room = type.getUnsolvedRoom(); setRoom(room, i); } } @@ -102,7 +91,7 @@ public class Raid continue; } - if (rooms[room.getPosition()].getType() == RaidRoom.Type.COMBAT) + if (rooms[room.getPosition()].getType() == RoomType.COMBAT) { combatRooms.add(rooms[room.getPosition()]); } @@ -113,7 +102,7 @@ public class Raid public String getRotationString() { - return Joiner.on(",").join(Arrays.stream(getCombatRooms()).map(r -> r.getBoss().getName()).toArray()); + return Joiner.on(",").join(Arrays.stream(getCombatRooms()).map(RaidRoom::getName).toArray()); } public String toCode() @@ -144,7 +133,7 @@ public class Raid final int position = r.getPosition(); final RaidRoom room = getRoom(position); - if (room == null || !(room.getType() == RaidRoom.Type.COMBAT || room.getType() == RaidRoom.Type.PUZZLE)) + if (room == null) { continue; } @@ -152,26 +141,8 @@ public class Raid switch (room.getType()) { case PUZZLE: - final RaidRoom.Puzzle puzzle = room.getPuzzle(); - sb.append(puzzle.getName()); - - if (puzzle == RaidRoom.Puzzle.UNKNOWN) - { - sb.append(" (puzzle)"); - } - - sb.append(", "); - break; case COMBAT: - final RaidRoom.Boss boss = room.getBoss(); - sb.append(boss.getName()); - - if (boss == RaidRoom.Boss.UNKNOWN) - { - sb.append(" (combat)"); - } - - sb.append(", "); + sb.append(room.getName()).append(", "); break; } } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidRoom.java b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidRoom.java index 23df0ff407..06101d6e08 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidRoom.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidRoom.java @@ -24,144 +24,37 @@ */ package net.runelite.client.plugins.raids; -import lombok.AllArgsConstructor; import lombok.Getter; -import lombok.Setter; -import net.runelite.api.Tile; +import lombok.RequiredArgsConstructor; -public class RaidRoom +@RequiredArgsConstructor +@Getter +enum RaidRoom { - public static final int ROOM_MAX_SIZE = 32; + START("Start", RoomType.START), + END("End", RoomType.END), + SCAVENGERS("Scavengers", RoomType.SCAVENGERS), + FARMING("Farming", RoomType.FARMING), + EMPTY("Empty", RoomType.EMPTY), - @AllArgsConstructor - public enum Type - { - START("Start", "#"), - END("End", "¤"), - SCAVENGERS("Scavengers", "S"), - FARMING("Farming", "F"), - COMBAT("Combat", "C"), - PUZZLE("Puzzle", "P"), - EMPTY("Empty", " "); + TEKTON("Tekton", RoomType.COMBAT), + MUTTADILES("Muttadiles", RoomType.COMBAT), + GUARDIANS("Guardians", RoomType.COMBAT), + VESPULA("Vespula", RoomType.COMBAT), + SHAMANS("Shamans", RoomType.COMBAT), + VASA("Vasa", RoomType.COMBAT), + VANGUARDS("Vanguards", RoomType.COMBAT), + MYSTICS("Mystics", RoomType.COMBAT), + UNKNOWN_COMBAT("Unknown (combat)", RoomType.COMBAT), - @Getter - private final String name; + CRABS("Crabs", RoomType.PUZZLE), + ICE_DEMON("Ice Demon", RoomType.PUZZLE), + TIGHTROPE("Tightrope", RoomType.PUZZLE), + THIEVING("Thieving", RoomType.PUZZLE), + UNKNOWN_PUZZLE("Unknown (puzzle)", RoomType.PUZZLE); - @Getter - private final String code; + static final int ROOM_MAX_SIZE = 32; - public static Type fromCode(char code) - { - for (Type type : Type.values()) - { - if (type.getCode().equalsIgnoreCase(String.valueOf(code))) - { - return type; - } - } - - return Type.EMPTY; - } - } - - @AllArgsConstructor - public enum Boss - { - TEKTON("Tekton"), - MUTTADILES("Muttadiles"), - GUARDIANS("Guardians"), - VESPULA("Vespula"), - SHAMANS("Shamans"), - VASA("Vasa"), - VANGUARDS("Vanguards"), - MYSTICS("Mystics"), - UNKNOWN("Unknown"); - - @Getter - private final String name; - - public static Boss fromString(String name) - { - for (Boss boss : Boss.values()) - { - if (boss.getName().equalsIgnoreCase(name)) - { - return boss; - } - } - - return null; - } - } - - @AllArgsConstructor - public enum Puzzle - { - CRABS("Crabs"), - ICE_DEMON("Ice Demon"), - TIGHTROPE("Tightrope"), - THIEVING("Thieving"), - UNKNOWN("Unknown"); - - @Getter - private final String name; - - public static Puzzle fromString(String name) - { - for (Puzzle puzzle : Puzzle.values()) - { - if (puzzle.getName().equalsIgnoreCase(name)) - { - return puzzle; - } - } - - return null; - } - } - - @Getter - private final Tile base; - - @Getter - @Setter - private Type type; - - @Getter - @Setter - private Boss boss; - - @Getter - @Setter - private Puzzle puzzle; - - @Getter - @Setter - private RaidRoom previousRoom; - - @Getter - @Setter - private RaidRoom nextRoom; - - public RaidRoom(Tile base, Type type) - { - this.base = base; - this.type = type; - } - - @Override - public String toString() - { - switch (type) - { - case COMBAT: - return "RaidRoom (type: " + type.getName() + ", " + boss.getName() + ")"; - - case PUZZLE: - return "RaidRoom (type: " + type.getName() + ", " + puzzle.getName() + ")"; - - default: - return "RaidRoom (type: " + type.getName() + ")"; - } - } + private final String name; + private final RoomType type; } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsOverlay.java b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsOverlay.java index 9613d2e643..3f572adf2a 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsOverlay.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsOverlay.java @@ -125,37 +125,41 @@ public class RaidsOverlay extends Overlay { case COMBAT: bossCount++; - if (plugin.getRoomWhitelist().contains(room.getBoss().getName().toLowerCase())) + if (plugin.getRoomWhitelist().contains(room.getName().toLowerCase())) { color = Color.GREEN; } - else if (plugin.getRoomBlacklist().contains(room.getBoss().getName().toLowerCase()) + else if (plugin.getRoomBlacklist().contains(room.getName().toLowerCase()) || config.enableRotationWhitelist() && bossCount > bossMatches) { color = Color.RED; } + String name = room == RaidRoom.UNKNOWN_COMBAT ? "Unknown" : room.getName(); + panelComponent.getChildren().add(LineComponent.builder() .left(room.getType().getName()) - .right(room.getBoss().getName()) + .right(name) .rightColor(color) .build()); break; case PUZZLE: - if (plugin.getRoomWhitelist().contains(room.getPuzzle().getName().toLowerCase())) + if (plugin.getRoomWhitelist().contains(room.getName().toLowerCase())) { color = Color.GREEN; } - else if (plugin.getRoomBlacklist().contains(room.getPuzzle().getName().toLowerCase())) + else if (plugin.getRoomBlacklist().contains(room.getName().toLowerCase())) { color = Color.RED; } + name = room == RaidRoom.UNKNOWN_PUZZLE ? "Unknown" : room.getName(); + panelComponent.getChildren().add(LineComponent.builder() .left(room.getType().getName()) - .right(room.getPuzzle().getName()) + .right(name) .rightColor(color) .build()); break; diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsPlugin.java index 7c075b8767..2dd6a321ec 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsPlugin.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsPlugin.java @@ -63,7 +63,6 @@ import net.runelite.client.plugins.Plugin; import net.runelite.client.plugins.PluginDescriptor; import net.runelite.client.plugins.raids.solver.Layout; import net.runelite.client.plugins.raids.solver.LayoutSolver; -import net.runelite.client.plugins.raids.solver.RotationSolver; import net.runelite.client.ui.overlay.OverlayManager; import net.runelite.client.ui.overlay.infobox.InfoBoxManager; import net.runelite.client.util.Text; @@ -544,97 +543,69 @@ public class RaidsPlugin extends Plugin private RaidRoom determineRoom(Tile base) { - RaidRoom room = new RaidRoom(base, RaidRoom.Type.EMPTY); int chunkData = client.getInstanceTemplateChunks()[base.getPlane()][(base.getSceneLocation().getX()) / 8][base.getSceneLocation().getY() / 8]; InstanceTemplates template = InstanceTemplates.findMatch(chunkData); if (template == null) { - return room; + return RaidRoom.EMPTY; } switch (template) { case RAIDS_LOBBY: case RAIDS_START: - room.setType(RaidRoom.Type.START); - break; + return RaidRoom.START; case RAIDS_END: - room.setType(RaidRoom.Type.END); - break; + return RaidRoom.END; case RAIDS_SCAVENGERS: case RAIDS_SCAVENGERS2: - room.setType(RaidRoom.Type.SCAVENGERS); - break; + return RaidRoom.SCAVENGERS; case RAIDS_SHAMANS: - room.setType(RaidRoom.Type.COMBAT); - room.setBoss(RaidRoom.Boss.SHAMANS); - break; + return RaidRoom.SHAMANS; case RAIDS_VASA: - room.setType(RaidRoom.Type.COMBAT); - room.setBoss(RaidRoom.Boss.VASA); - break; + return RaidRoom.VASA; case RAIDS_VANGUARDS: - room.setType(RaidRoom.Type.COMBAT); - room.setBoss(RaidRoom.Boss.VANGUARDS); - break; + return RaidRoom.VANGUARDS; case RAIDS_ICE_DEMON: - room.setType(RaidRoom.Type.PUZZLE); - room.setPuzzle(RaidRoom.Puzzle.ICE_DEMON); - break; + return RaidRoom.ICE_DEMON; case RAIDS_THIEVING: - room.setType(RaidRoom.Type.PUZZLE); - room.setPuzzle(RaidRoom.Puzzle.THIEVING); - break; + return RaidRoom.THIEVING; case RAIDS_FARMING: case RAIDS_FARMING2: - room.setType(RaidRoom.Type.FARMING); - break; + return RaidRoom.FARMING; case RAIDS_MUTTADILES: - room.setType(RaidRoom.Type.COMBAT); - room.setBoss(RaidRoom.Boss.MUTTADILES); - break; + return RaidRoom.MUTTADILES; case RAIDS_MYSTICS: - room.setType(RaidRoom.Type.COMBAT); - room.setBoss(RaidRoom.Boss.MYSTICS); - break; + return RaidRoom.MYSTICS; case RAIDS_TEKTON: - room.setType(RaidRoom.Type.COMBAT); - room.setBoss(RaidRoom.Boss.TEKTON); - break; + return RaidRoom.TEKTON; case RAIDS_TIGHTROPE: - room.setType(RaidRoom.Type.PUZZLE); - room.setPuzzle(RaidRoom.Puzzle.TIGHTROPE); - break; + return RaidRoom.TIGHTROPE; case RAIDS_GUARDIANS: - room.setType(RaidRoom.Type.COMBAT); - room.setBoss(RaidRoom.Boss.GUARDIANS); - break; + return RaidRoom.GUARDIANS; case RAIDS_CRABS: - room.setType(RaidRoom.Type.PUZZLE); - room.setPuzzle(RaidRoom.Puzzle.CRABS); - break; + return RaidRoom.CRABS; case RAIDS_VESPULA: - room.setType(RaidRoom.Type.COMBAT); - room.setBoss(RaidRoom.Boss.VESPULA); - break; - } + return RaidRoom.VESPULA; - return room; + default: + return RaidRoom.EMPTY; + } } } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/raids/RoomType.java b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RoomType.java new file mode 100644 index 0000000000..686391e563 --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RoomType.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2018, Kamiel + * Copyright (c) 2019, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.client.plugins.raids; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +@AllArgsConstructor +@Getter +enum RoomType +{ + START("Start", '#'), + END("End", '¤'), + SCAVENGERS("Scavengers", 'S'), + FARMING("Farming", 'F'), + EMPTY("Empty", ' '), + COMBAT("Combat", 'C'), + PUZZLE("Puzzle", 'P'); + + private final String name; + private final char code; + + RaidRoom getUnsolvedRoom() + { + switch (this) + { + case START: + return RaidRoom.START; + case END: + return RaidRoom.END; + case SCAVENGERS: + return RaidRoom.SCAVENGERS; + case FARMING: + return RaidRoom.FARMING; + case COMBAT: + return RaidRoom.UNKNOWN_COMBAT; + case PUZZLE: + return RaidRoom.UNKNOWN_PUZZLE; + case EMPTY: + default: + return RaidRoom.EMPTY; + } + } + + static RoomType fromCode(char code) + { + for (RoomType type : values()) + { + if (type.getCode() == code) + { + return type; + } + } + + return EMPTY; + } +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/raids/solver/RotationSolver.java b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RotationSolver.java similarity index 57% rename from runelite-client/src/main/java/net/runelite/client/plugins/raids/solver/RotationSolver.java rename to runelite-client/src/main/java/net/runelite/client/plugins/raids/RotationSolver.java index 1acf3ed2df..b9179cea1b 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/raids/solver/RotationSolver.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/raids/RotationSolver.java @@ -22,58 +22,45 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package net.runelite.client.plugins.raids.solver; +package net.runelite.client.plugins.raids; -import java.util.ArrayList; import java.util.Arrays; -import java.util.Collection; -import net.runelite.client.plugins.raids.RaidRoom; -import net.runelite.client.plugins.raids.RaidRoom.Boss; +import java.util.List; +import static net.runelite.client.plugins.raids.RaidRoom.GUARDIANS; +import static net.runelite.client.plugins.raids.RaidRoom.MUTTADILES; +import static net.runelite.client.plugins.raids.RaidRoom.MYSTICS; +import static net.runelite.client.plugins.raids.RaidRoom.SHAMANS; +import static net.runelite.client.plugins.raids.RaidRoom.TEKTON; +import static net.runelite.client.plugins.raids.RaidRoom.UNKNOWN_COMBAT; +import static net.runelite.client.plugins.raids.RaidRoom.VANGUARDS; +import static net.runelite.client.plugins.raids.RaidRoom.VASA; +import static net.runelite.client.plugins.raids.RaidRoom.VESPULA; -public class RotationSolver +class RotationSolver { - private static class Rotation extends ArrayList - { - Rotation(Collection bosses) + private static final List[] ROTATIONS = { - super(bosses); - } + Arrays.asList(TEKTON, VASA, GUARDIANS, MYSTICS, SHAMANS, MUTTADILES, VANGUARDS, VESPULA), + Arrays.asList(TEKTON, MUTTADILES, GUARDIANS, VESPULA, SHAMANS, VASA, VANGUARDS, MYSTICS), + Arrays.asList(VESPULA, VANGUARDS, MUTTADILES, SHAMANS, MYSTICS, GUARDIANS, VASA, TEKTON), + Arrays.asList(MYSTICS, VANGUARDS, VASA, SHAMANS, VESPULA, GUARDIANS, MUTTADILES, TEKTON) + }; - @Override - public E get(int index) - { - if (index < 0) - { - index = index + size(); - } - - return super.get(index % size()); - } - } - - private static final Rotation[] ROTATIONS = - { - new Rotation<>(Arrays.asList(Boss.TEKTON, Boss.VASA, Boss.GUARDIANS, Boss.MYSTICS, Boss.SHAMANS, Boss.MUTTADILES, Boss.VANGUARDS, Boss.VESPULA)), - new Rotation<>(Arrays.asList(Boss.TEKTON, Boss.MUTTADILES, Boss.GUARDIANS, Boss.VESPULA, Boss.SHAMANS, Boss.VASA, Boss.VANGUARDS, Boss.MYSTICS)), - new Rotation<>(Arrays.asList(Boss.VESPULA, Boss.VANGUARDS, Boss.MUTTADILES, Boss.SHAMANS, Boss.MYSTICS, Boss.GUARDIANS, Boss.VASA, Boss.TEKTON)), - new Rotation<>(Arrays.asList(Boss.MYSTICS, Boss.VANGUARDS, Boss.VASA, Boss.SHAMANS, Boss.VESPULA, Boss.GUARDIANS, Boss.MUTTADILES, Boss.TEKTON)) - }; - - public static boolean solve(RaidRoom[] rooms) + static boolean solve(RaidRoom[] rooms) { if (rooms == null) { return false; } - Rotation match = null; + List match = null; Integer start = null; Integer index = null; int known = 0; for (int i = 0; i < rooms.length; i++) { - if (rooms[i] == null || rooms[i].getBoss() == null || rooms[i].getBoss() == Boss.UNKNOWN) + if (rooms[i] == null || rooms[i].getType() != RoomType.COMBAT || rooms[i] == UNKNOWN_COMBAT) { continue; } @@ -96,21 +83,21 @@ public class RotationSolver return true; } - for (Rotation rotation : ROTATIONS) + for (List rotation : ROTATIONS) { COMPARE: for (int i = 0; i < rotation.size(); i++) { - if (rooms[start].getBoss() == rotation.get(i)) + if (rooms[start] == rotation.get(i)) { for (int j = start + 1; j < rooms.length; j++) { - if (rooms[j].getBoss() == null || rooms[j].getBoss() == Boss.UNKNOWN) + if (rooms[j].getType() != RoomType.COMBAT || rooms[j] == UNKNOWN_COMBAT) { continue; } - if (rooms[j].getBoss() != rotation.get(i + j - start)) + if (rooms[j] != rotation.get((i + j - start) % rotation.size())) { break COMPARE; } @@ -139,9 +126,9 @@ public class RotationSolver continue; } - if (rooms[i].getBoss() == null || rooms[i].getBoss() == Boss.UNKNOWN) + if (rooms[i].getType() != RoomType.COMBAT || rooms[i] == UNKNOWN_COMBAT) { - rooms[i].setBoss(match.get(index + i)); + rooms[i] = match.get((index + i) % match.size()); } } diff --git a/runelite-client/src/test/java/net/runelite/client/plugins/raids/RotationSolverTest.java b/runelite-client/src/test/java/net/runelite/client/plugins/raids/RotationSolverTest.java new file mode 100644 index 0000000000..5c2bba30e6 --- /dev/null +++ b/runelite-client/src/test/java/net/runelite/client/plugins/raids/RotationSolverTest.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2019, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.client.plugins.raids; + +import static net.runelite.client.plugins.raids.RaidRoom.GUARDIANS; +import static net.runelite.client.plugins.raids.RaidRoom.MUTTADILES; +import static net.runelite.client.plugins.raids.RaidRoom.MYSTICS; +import static net.runelite.client.plugins.raids.RaidRoom.SHAMANS; +import static net.runelite.client.plugins.raids.RaidRoom.TEKTON; +import static net.runelite.client.plugins.raids.RaidRoom.UNKNOWN_COMBAT; +import static net.runelite.client.plugins.raids.RaidRoom.VANGUARDS; +import static net.runelite.client.plugins.raids.RaidRoom.VASA; +import static net.runelite.client.plugins.raids.RaidRoom.VESPULA; +import static org.junit.Assert.assertArrayEquals; +import org.junit.Test; + +public class RotationSolverTest +{ + @Test + public void testSolve1() + { + RaidRoom[] rooms = new RaidRoom[]{VESPULA, UNKNOWN_COMBAT, UNKNOWN_COMBAT, VANGUARDS}; + RotationSolver.solve(rooms); + assertArrayEquals(new RaidRoom[]{VESPULA, SHAMANS, VASA, VANGUARDS}, rooms); + } + + @Test + public void testSolve2() + { + RaidRoom[] rooms = new RaidRoom[]{UNKNOWN_COMBAT, UNKNOWN_COMBAT, MUTTADILES, TEKTON}; + RotationSolver.solve(rooms); + assertArrayEquals(new RaidRoom[]{VESPULA, GUARDIANS, MUTTADILES, TEKTON}, rooms); + } + + @Test + public void testSolve3() + { + RaidRoom[] rooms = new RaidRoom[]{TEKTON, UNKNOWN_COMBAT, GUARDIANS, MYSTICS}; + RotationSolver.solve(rooms); + assertArrayEquals(new RaidRoom[]{TEKTON, VASA, GUARDIANS, MYSTICS}, rooms); + } + + @Test + public void testSolve4() + { + RaidRoom[] rooms = new RaidRoom[]{VASA, UNKNOWN_COMBAT, UNKNOWN_COMBAT, GUARDIANS}; + RotationSolver.solve(rooms); + assertArrayEquals(new RaidRoom[]{VASA, SHAMANS, VESPULA, GUARDIANS}, rooms); + } +} \ No newline at end of file